perf: replace ref cells with mutable in singleton, collectSeq, takeWhileInclusive, takeWhileInclusiveAsync

Modernises 4 remaining functions that still used old-style ref cells
(! / := operators) to use mutable local variables instead. This eliminates
heap-allocated Ref<T> objects in these enumerators, reducing GC pressure.

- singleton: state ref 0 -> mutable state = 0
- collectSeq: state ref (CollectSeqState...) -> mutable state
- takeWhileInclusive: fin ref false -> mutable fin = false
- takeWhileInclusiveAsync: fin ref false -> mutable fin = false

All 402 tests pass.

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

Author: github-actions[bot]

RELEASE_NOTES.md

@@ -1,6 +1,7 @@
 ### 4.12.0
 
 * Tests: Added tests for `mapiAsync`, `tryPickAsync`, `pickAsync`, and `groupByAsync` — these four async functions previously had no test coverage.
+* Performance: Modernised `singleton`, `collectSeq`, `takeWhileInclusive`, and `takeWhileInclusiveAsync` to use `mutable` local variables instead of `ref` cells (`!`/`:=` operators). Eliminates heap-allocated `Ref<T>` objects in these enumerators, reducing GC pressure consistent with the improvements in 4.11.0.
 * Added `AsyncSeq.tryFindBack` — returns the last element for which the predicate returns true, or `None` if no match. Mirrors `Array.tryFindBack` / `List.tryFindBack`.
 * Added `AsyncSeq.tryFindBackAsync` — async-predicate variant of `tryFindBack`.
 * Added `AsyncSeq.findBack` — returns the last element for which the predicate returns true; raises `KeyNotFoundException` if no match. Mirrors `Array.findBack` / `List.findBack`.

src/FSharp.Control.AsyncSeq/AsyncSeq.fs

@@ -450,11 +450,11 @@ module AsyncSeq =
 
   let singleton (v:'T) : AsyncSeq<'T> =
     AsyncSeqImpl(fun () ->
-        let state = ref 0
+        let mutable state = 0
         { new IAsyncSeqEnumerator<'T> with
             member _.MoveNext() = async {
-                let res = state.Value = 0
-                incr state
+                let res = state = 0
+                state <- state + 1
                 return (if res then Some v else None) }
           interface System.IDisposable with
             member _.Dispose() = () }) :> AsyncSeq<'T>
@@ -719,20 +719,20 @@ module AsyncSeq =
   // Like collect, but the input is a sequence, where no bind is required on each step of the enumeration
   let collectSeq (f: 'T -> AsyncSeq<'U>) (inp: seq<'T>) : AsyncSeq<'U> =
         AsyncSeqImpl(fun () ->
-            let state = ref (CollectSeqState.NotStarted inp)
+            let mutable state = CollectSeqState.NotStarted inp
             { new IAsyncSeqEnumerator<'U> with
                         member x.MoveNext() =
-                            async { match !state with
+                            async { match state with
                                     | CollectSeqState.NotStarted inp ->
                                         return!
                                            (let e1 = inp.GetEnumerator()
-                                            state := CollectSeqState.HaveInputEnumerator e1
+                                            state <- CollectSeqState.HaveInputEnumerator e1
                                             x.MoveNext())
                                     | CollectSeqState.HaveInputEnumerator e1 ->
                                         return!
                                           (if e1.MoveNext()  then
                                                let e2 = (f e1.Current).GetEnumerator()
-                                               state := CollectSeqState.HaveInnerEnumerator (e1, e2)
+                                               state <- CollectSeqState.HaveInnerEnumerator (e1, e2)
                                            else
                                                x.Dispose()
                                            x.MoveNext())
@@ -741,19 +741,19 @@ module AsyncSeq =
                                         match res2 with
                                         | None ->
                                             return!
-                                              (state := CollectSeqState.HaveInputEnumerator e1
+                                              (state <- CollectSeqState.HaveInputEnumerator e1
                                                dispose e2
                                                x.MoveNext())
                                         | Some _ ->
                                             return res2
                                     | _ -> return None}
                         member x.Dispose() =
-                            match !state with
+                            match state with
                             | CollectSeqState.HaveInputEnumerator e1 ->
-                                state := CollectSeqState.Finished
+                                state <- CollectSeqState.Finished
                                 dispose e1
                             | CollectSeqState.HaveInnerEnumerator (e1, e2) ->
-                                state := CollectSeqState.Finished
+                                state <- CollectSeqState.Finished
                                 dispose e2
                                 dispose e1
                                 x.Dispose()
@@ -1982,35 +1982,35 @@ module AsyncSeq =
   let takeWhileInclusive (f : 'a -> bool) (s : AsyncSeq<'a>) : AsyncSeq<'a> =
     AsyncSeqImpl(fun () ->
         let en = s.GetEnumerator()
-        let fin = ref false
+        let mutable fin = false
         { new IAsyncSeqEnumerator<'a> with
             member _.MoveNext() = async {
-                if !fin then return None
+                if fin then return None
                 else
                     let! next = en.MoveNext()
                     match next with
                     | None -> return None
                     | Some a ->
                         if f a then return Some a
-                        else fin := true; return Some a }
+                        else fin <- true; return Some a }
           interface System.IDisposable with
             member _.Dispose() = en.Dispose() }) :> AsyncSeq<'a>
 
   let takeWhileInclusiveAsync (predicate: 'T -> Async<bool>) (source: AsyncSeq<'T>) : AsyncSeq<'T> =
     AsyncSeqImpl(fun () ->
         let en = source.GetEnumerator()
-        let fin = ref false
+        let mutable fin = false
         { new IAsyncSeqEnumerator<'T> with
             member _.MoveNext() = async {
-                if !fin then return None
+                if fin then return None
                 else
                     let! next = en.MoveNext()
                     match next with
                     | None -> return None
                     | Some a ->
                         let! ok = predicate a
                         if ok then return Some a
-                        else fin := true; return Some a }
+                        else fin <- true; return Some a }
           interface System.IDisposable with
             member _.Dispose() = en.Dispose() }) :> AsyncSeq<'T>