perf: optimize TaskSeq.replicate with direct object-expression implementation

Replaces the taskSeq CE (which uses a resumable state machine) and a 1..count
range IEnumerable with a minimal direct IAsyncEnumerable/IAsyncEnumerator
object expression, matching the pattern used by empty and singleton.

Benefits:
- No state machine allocation
- No range IEnumerable or IEnumerator allocation
- MoveNextAsync always completes synchronously (ValueTask<bool> hot path)
- DisposeAsync is a no-op returning ValueTask.CompletedTask

All 8 existing replicate tests pass, 4634 total tests pass.

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

Author: github-actions[bot]

release-notes.txt

@@ -3,6 +3,7 @@ Release notes:
 
 0.6.0
     - fixes: async { for item in taskSeq do ... } no longer wraps exceptions in AggregateException, #129
+    - performance: TaskSeq.replicate now uses a direct object-expression implementation, avoiding the taskSeq CE state machine and range IEnumerable/IEnumerator allocation
     - adds TaskSeq.compareWith and TaskSeq.compareWithAsync
     - adds TaskSeq.scan and TaskSeq.scanAsync, #289
     - adds TaskSeq.pairwise, #289

src/FSharp.Control.TaskSeq/TaskSeqInternal.fs

@@ -147,9 +147,22 @@ module internal TaskSeqInternal =
     let replicate count value =
         raiseCannotBeNegative (nameof count) count
 
-        taskSeq {
-            for _ in 1..count do
-                yield value
+        // Direct object-expression implementation: avoids the taskSeq CE state machine,
+        // the 1..count range IEnumerable, and its IEnumerator — all of which are unnecessary
+        // for this simple, always-synchronous sequence. MoveNextAsync always completes
+        // synchronously, which is the optimal fast path for ValueTask consumers.
+        { new IAsyncEnumerable<'T> with
+            member _.GetAsyncEnumerator _ =
+                let mutable i = 0
+
+                { new IAsyncEnumerator<'T> with
+                    member _.MoveNextAsync() =
+                        i <- i + 1
+                        ValueTask<bool>(i <= count)
+
+                    member _.Current = value
+                    member _.DisposeAsync() = ValueTask.CompletedTask
+                }
         }
 
     /// Returns length unconditionally, or based on a predicate