feat: add TaskSeq.exists2, forall2, forall2Async, fold2, fold2Async (206 tests)

Implements the next batch of '2'-functions from the README roadmap:

  TaskSeq.exists2     : ('T -> 'U -> bool)          -> TaskSeq<'T> -> TaskSeq<'U> -> Task<bool>
  TaskSeq.forall2     : ('T -> 'U -> bool)          -> TaskSeq<'T> -> TaskSeq<'U> -> Task<bool>
  TaskSeq.forall2Async: ('T -> 'U -> #Task<bool>)   -> TaskSeq<'T> -> TaskSeq<'U> -> Task<bool>
  TaskSeq.fold2       : ('S -> 'T -> 'U -> 'S)      -> 'S -> TaskSeq<'T> -> TaskSeq<'U> -> Task<'S>
  TaskSeq.fold2Async  : ('S -> 'T -> 'U -> #Task<'S>) -> 'S -> TaskSeq<'T> -> TaskSeq<'U> -> Task<'S>

Semantics: stop at the shorter sequence (consistent with map2/iter2/zip).

Files changed:
- TaskSeqInternal.fs: exists2, forall2, forall2Async, fold2, fold2Async
- TaskSeq.fs: wrapper members
- TaskSeq.fsi: public signatures with XML doc
- TaskSeq.Exists2Forall2Fold2.Tests.fs: 206 tests (null, empty, immutable, side-effects)
- FSharp.Control.TaskSeq.Test.fsproj: new test file reference
- release-notes.txt: entry under v0.6.0
- README.md: mark exists2, fold2/fold2Async, forall2/forall2Async as done

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

README.md

@@ -214,7 +214,7 @@ The `TaskSeq` project already has a wide array of functions and functionalities,
   - [x] `chunkBySize` / `windowed` (see [#258])
   - [ ] `compareWith`
   - [ ] `distinct`
-  - [ ] `exists2` / `map2` / `fold2` / `iter2` and related '2'-functions
+  - [ ] `exists2` / `map2` / `iter2` and related '2'-functions (partial: `exists2`, `forall2`, `forall2Async`, `fold2`, `fold2Async` done)
   - [ ] `mapFold`
   - [x] `pairwise` (see [#293])
   - [ ] `allpairs` / `permute` / `distinct` / `distinctBy`
@@ -283,18 +283,18 @@ This is what has been implemented so far, is planned or skipped:
 | ✅ [#83][] | `except`           | `except`             |                           | |
 | ✅ [#83][] |                    | `exceptOfSeq`        |                           | |
 | ✅ [#70][] | `exists`           | `exists`             | `existsAsync`             | |
-|                  | `exists2`          | `exists2`            |                           | |
+| ✅         |                    | `exists2`            |                           | |
 | ✅ [#23][] | `filter`           | `filter`             | `filterAsync`             | |
 | ✅ [#23][] | `find`             | `find`               | `findAsync`               | |
 | 🚫        | `findBack`         |                      |                           | [note #2](#note2 "Because of the async nature of TaskSeq sequences, iterating from the back would be bad practice. Instead, materialize the sequence to a list or array and then apply the 'Back' iterators.") |
 | ✅ [#68][] | `findIndex`        | `findIndex`          | `findIndexAsync`          | |
 | 🚫        | `findIndexBack`    | n/a                  | n/a                       | [note #2](#note2 "Because of the async nature of TaskSeq sequences, iterating from the back would be bad practice. Instead, materialize the sequence to a list or array and then apply the 'Back' iterators.") |
 | ✅ [#2][]  | `fold`             | `fold`               | `foldAsync`               | |
-|                  | `fold2`            | `fold2`              | `fold2Async`              | |
+| ✅         |                    | `fold2`              | `fold2Async`              | |
 | 🚫        | `foldBack`         |                      |                           | [note #2](#note2 "Because of the async nature of TaskSeq sequences, iterating from the back would be bad practice. Instead, materialize the sequence to a list or array and then apply the 'Back' iterators.") |
 | 🚫        | `foldBack2`        |                      |                           | [note #2](#note2 "Because of the async nature of TaskSeq sequences, iterating from the back would be bad practice. Instead, materialize the sequence to a list or array and then apply the 'Back' iterators.") |
 | ✅ [#240][]| `forall`           | `forall`             | `forallAsync`             | |
-|                  | `forall2`          | `forall2`            | `forall2Async`            | |
+| ✅         |                    | `forall2`            | `forall2Async`            | |
 | ❓         | `groupBy`          | `groupBy`            | `groupByAsync`            | [note #1](#note1 "These functions require a form of pre-materializing through 'TaskSeq.cache', similar to the approach taken in the corresponding 'Seq' functions. It doesn't make much sense to have a cached async sequence. However, 'AsyncSeq' does implement these, so we'll probably do so eventually as well.") |
 | ✅ [#23][] | `head`             | `head`               |                           | |
 | ✅ [#68][] | `indexed`          | `indexed`            |                           | |

release-notes.txt

@@ -17,6 +17,7 @@ Release notes:
     - adds TaskSeq.unfold and TaskSeq.unfoldAsync, #289
     - adds TaskSeq.chunkBySize (closes #258) and TaskSeq.windowed, #289
     - fixes: CancellationToken passed to GetAsyncEnumerator is now honored in MoveNextAsync, #179
+    - adds TaskSeq.exists2, forall2, forall2Async, fold2, fold2Async
 
 0.5.0
     - update engineering to .NET 9/10

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

@@ -23,6 +23,7 @@
     <Compile Include="TaskSeq.Distinct.Tests.fs" />
     <Compile Include="TaskSeq.Pairwise.Tests.fs" />
     <Compile Include="TaskSeq.Exists.Tests.fs" />
+    <Compile Include="TaskSeq.Exists2Forall2Fold2.Tests.fs" />
     <Compile Include="TaskSeq.Filter.Tests.fs" />
     <Compile Include="TaskSeq.FindIndex.Tests.fs" />
     <Compile Include="TaskSeq.Find.Tests.fs" />