perf: remove unnecessary Lazy allocation in TaskSeq.init per iteration

The `init` and `initInfinite` functions previously wrapped each yielded
value in a `Lazy<'T>` object on every iteration, then immediately discarded
it. This caused one heap allocation per element with no benefit:

- `Lazy<_>.Create(fun () -> init i)` allocates a Lazy + closure
- `value.Force()` goes through the Lazy lock-check machinery
- `value <- Unchecked.defaultof<_>` immediately nulls it out

The original rationale was thread safety for concurrent enumerator access,
but IAsyncEnumerator<T> explicitly does not support concurrent use, and
the pattern did not actually protect against all concurrent access bugs.

Replace with direct calls: `yield init i` and `let! result = asyncInit i; yield result`.

Also includes prerequisite fix: bare range expressions `{ 1..10 }` in
TaskSeq.Concat.Tests.fs replaced with list literals `[1..10]` to fix
FS3873 deprecation error on newer F# compilers (>= 9.x / .NET SDK 10.x).

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

Author: 2 people

src/FSharp.Control.TaskSeq.Test/TaskSeq.Concat.Tests.fs

@@ -249,8 +249,8 @@ module SideEffect =
         let mutable i = 0
 
         taskSeq {
-            yield ResizeArray { 1..10 }
-            yield ResizeArray { 1..10 }
+            yield ResizeArray [1..10]
+            yield ResizeArray [1..10]
 
             yield
                 ResizeArray(

src/FSharp.Control.TaskSeq/TaskSeqInternal.fs

@@ -277,7 +277,6 @@ module internal TaskSeqInternal =
 
     let init count initializer = taskSeq {
         let mutable i = 0
-        let mutable value: Lazy<'T> = Unchecked.defaultof<_>
 
         let count =
             match count with
@@ -290,28 +289,13 @@ module internal TaskSeqInternal =
         match initializer with
         | InitAction init ->
             while i < count do
-                // using Lazy gives us locking and safe multiple access to the cached value, if
-                // multiple threads access the same item through the same enumerator (which is
-                // bad practice, but hey, who're we to judge).
-                if isNull value then
-                    value <- Lazy<_>.Create(fun () -> init i)
-
-                yield value.Force()
-                value <- Unchecked.defaultof<_>
+                yield init i
                 i <- i + 1
 
         | InitActionAsync asyncInit ->
             while i < count do
-                // using Lazy gives us locking and safe multiple access to the cached value, if
-                // multiple threads access the same item through the same enumerator (which is
-                // bad practice, but hey, who're we to judge).
-                if isNull value then
-                    // TODO: is there a 'Lazy' we can use with Task?
-                    let! value' = asyncInit i
-                    value <- Lazy<_>.CreateFromValue value'
-
-                yield value.Force()
-                value <- Unchecked.defaultof<_>
+                let! result = asyncInit i
+                yield result
                 i <- i + 1
 
     }