refactor: replace FoldStep DU with foldWhile predicate+folder API

Reworks the early-termination fold added in 7bde226 to match the
conventions of FSharp.Control.TaskSeq: bool-returning predicate + plain
folder, and no new public DU. Every other early-termination API in the
library (takeWhile, skipWhile, tryFind, forall, exists) uses this
shape; every DU in the source is internal. FoldStep<'State> would have
been the only public DU, which is the inconsistency @dsyme flagged on
the PR.

API:
  - TaskSeq.foldWhile      : ('State -> 'T -> bool)
                           -> ('State -> 'T -> 'State)
                           -> 'State -> TaskSeq<'T> -> Task<'State>
  - TaskSeq.foldWhileAsync : ('State -> 'T -> #Task<bool>)
                           -> ('State -> 'T -> #Task<'State>)
                           -> 'State -> TaskSeq<'T> -> Task<'State>

Semantics (match takeWhile, exclusive): the predicate is evaluated
against (currentState, nextElement) before that element is folded. If
false, iteration halts without folding that element and the source is
not enumerated further.

Removes:
  - public FoldStep<'State> DU
  - internal FoldUntilAction DU
  - TaskSeq.foldUntil / foldUntilAsync

Tests: rewritten for exclusive semantics (halting element not folded,
predicate-call / folder-call counts asserted separately).
Full test suite green (5277 passed).

Author: Onur Gumus

release-notes.txt

@@ -2,7 +2,7 @@
 Release notes:
 
 Unreleased
-    - adds TaskSeq.foldUntil and TaskSeq.foldUntilAsync: fold with early termination via a FoldStep<'State> DU (Continue / Halt). The underlying sequence is not enumerated past the element that caused Halt.
+    - adds TaskSeq.foldWhile and TaskSeq.foldWhileAsync: fold with early termination via a (state, element) -> bool predicate (takeWhile-style, exclusive). When the predicate returns false, iteration halts without folding that element; no further elements are enumerated.
     - test: add SideEffects module and ImmTaskSeq variant tests to TaskSeq.ChunkBy.Tests.fs, improving coverage for chunkBy and chunkByAsync
     - fixes: `Async.bind` signature corrected from `(Async<'T> -> Async<'U>)` to `('T -> Async<'U>)` to match standard monadic bind semantics (same as `Task.bind`); the previous signature made the function effectively equivalent to direct application
     - refactor: simplify splitAt 'rest' taskSeq to use while!, removing redundant go2 mutable and manual MoveNextAsync pre-advance

src/FSharp.Control.TaskSeq.Test/FSharp.Control.TaskSeq.Test.fsproj

@@ -28,7 +28,7 @@
     <Compile Include="TaskSeq.FindIndex.Tests.fs" />
     <Compile Include="TaskSeq.Find.Tests.fs" />
     <Compile Include="TaskSeq.Fold.Tests.fs" />
-    <Compile Include="TaskSeq.FoldUntil.Tests.fs" />
+    <Compile Include="TaskSeq.FoldWhile.Tests.fs" />
     <Compile Include="TaskSeq.Scan.Tests.fs" />
     <Compile Include="TaskSeq.MapFold.Tests.fs" />
     <Compile Include="TaskSeq.Reduce.Tests.fs" />