Daily Test Coverage Improver: Add comprehensive tests for TaskSeqInternal and Builder

## Test Coverage Improvements

This PR adds comprehensive test coverage for previously untested or under-tested areas:

### TaskSeq.Internal.Tests.fs - TaskSeqInternal Module Coverage
- **Internal helper functions**: Tests for checkNonNull, raiseEmptySeq, raiseCannotBeNegative, raiseOutOfBounds, raiseInsufficient, raiseNotFound 
- **Core sequence functions**: isEmpty, empty, singleton, moveFirstOrRaiseUnsafe
- **Internal discriminated unions**: AsyncEnumStatus, TakeOrSkipKind, Action, FolderAction, ChooserAction, PredicateAction types
- **Error handling**: Comprehensive validation of all exception scenarios with correct parameter names and messages
- **Edge cases**: Null argument validation, boundary conditions, resource disposal

### TaskSeq.Builder.Tests.fs - Computation Expression Coverage  
- **Basic builder operations**: Empty expressions, single/multiple yields, yield! combinations
- **Async integration**: let! bindings, do! operations, Task.Delay integration
- **Control flow**: Conditional yields, for loops, while loops, nested loops
- **Exception handling**: try-with, try-finally blocks
- **Resource management**: use and use! for IDisposable and IAsyncDisposable
- **Advanced scenarios**: Complex async computations, cancellation token propagation, nested taskSeq expressions
- **Builder edge cases**: Empty yield!, multiple yield! operations, side effects, computation expression return

## Testing Approach

- **Internal testing**: Uses reflection to test TaskSeqInternal functions following F# testing best practices
- **Comprehensive scenarios**: Covers both success paths and error conditions  
- **Real-world usage**: Tests computation expression patterns commonly used in practice
- **Resource safety**: Validates proper disposal and cancellation behavior
- **Performance patterns**: Tests edge cases that could affect performance or correctness

## Technical Details

- **55 new test cases** across two comprehensive test modules
- Tests use xUnit with FsUnit assertions following existing project conventions
- All tests are async-compatible using F# task computation expressions
- Internal function tests use proper reflection with error handling for TargetInvocationException
- Builder tests cover all major computation expression constructs supported by taskSeq

🤖 Generated with [Daily Test Coverage Improver](https://github.com/fsprojects/FSharp.Control.TaskSeq/actions/runs/17180489760) may contain mistakes.

Author: github-actions[bot]

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

@@ -57,6 +57,8 @@
     <Compile Include="TaskSeq.Do.Tests.fs" />
     <Compile Include="TaskSeq.Let.Tests.fs" />
     <Compile Include="TaskSeq.Using.Tests.fs" />
+    <Compile Include="TaskSeq.Internal.Tests.fs" />
+    <Compile Include="TaskSeq.Builder.Tests.fs" />
   </ItemGroup>
 
   <ItemGroup>

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

@@ -0,0 +1,351 @@
+module TaskSeq.Tests.Builder
+
+open System
+open System.Reflection
+open System.Threading.Tasks
+open System.Collections.Generic
+open System.Threading
+
+open Xunit
+open FsUnit.Xunit
+
+open FSharp.Control
+
+//
+// Tests for TaskSeq computation expression builder edge cases
+// These test specific edge cases and internal builder functionality
+//
+
+[<Fact>]
+let ``taskSeq builder should handle empty computation expression`` () = task {
+    let emptySeq = taskSeq { () }
+    
+    let! items = TaskSeq.toListAsync emptySeq
+    items |> should be Empty
+}
+
+[<Fact>] 
+let ``taskSeq builder should handle single yield`` () = task {
+    let seq = taskSeq {
+        yield 42
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [42]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle multiple yields`` () = task {
+    let seq = taskSeq {
+        yield 1
+        yield 2  
+        yield 3
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [1; 2; 3]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle yield! with another TaskSeq`` () = task {
+    let innerSeq = taskSeq {
+        yield 1
+        yield 2
+    }
+    
+    let outerSeq = taskSeq {
+        yield 0
+        yield! innerSeq
+        yield 3
+    }
+    
+    let! items = TaskSeq.toListAsync outerSeq
+    items |> should equal [0; 1; 2; 3]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle yield! with regular sequence`` () = task {
+    let seq = taskSeq {
+        yield 0
+        yield! [1; 2; 3]
+        yield 4
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [0; 1; 2; 3; 4]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle async operations in do!`` () = task {
+    let mutable sideEffect = 0
+    
+    let seq = taskSeq {
+        do! Task.Delay(1)
+        sideEffect <- 42
+        yield sideEffect
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [42]
+    sideEffect |> should equal 42
+}
+
+[<Fact>]
+let ``taskSeq builder should handle let! with async values`` () = task {
+    let seq = taskSeq {
+        let! value = Task.FromResult(42)
+        yield value * 2
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [84]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle conditional yields`` () = task {
+    let seq = taskSeq {
+        for i in 1..5 do
+            if i % 2 = 0 then
+                yield i
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [2; 4]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle nested for loops`` () = task {
+    let seq = taskSeq {
+        for i in 1..2 do
+            for j in 1..2 do
+                yield (i, j)
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [(1, 1); (1, 2); (2, 1); (2, 2)]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle try-with exception handling`` () = task {
+    let seq = taskSeq {
+        try
+            yield 1
+            failwith "test error"
+            yield 2
+        with
+        | _ -> yield 999
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [1; 999]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle try-finally`` () = task {
+    let mutable finalized = false
+    
+    let seq = taskSeq {
+        try
+            yield 1
+            yield 2
+        finally
+            finalized <- true
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [1; 2]
+    finalized |> should equal true
+}
+
+[<Fact>]
+let ``taskSeq builder should handle use for disposable resources`` () = task {
+    let mutable disposed = false
+    
+    let disposable = { new IDisposable with
+        member _.Dispose() = disposed <- true }
+    
+    let seq = taskSeq {
+        use d = disposable
+        yield 42
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [42]
+    disposed |> should equal true
+}
+
+[<Fact>]
+let ``taskSeq builder should handle use! for async disposable resources`` () = task {
+    let mutable disposed = false
+    
+    let asyncDisposable = { new IAsyncDisposable with
+        member _.DisposeAsync() = 
+            disposed <- true
+            ValueTask.CompletedTask }
+    
+    let seq = taskSeq {
+        use! d = Task.FromResult(asyncDisposable)
+        yield 42
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [42]
+    disposed |> should equal true
+}
+
+[<Fact>]
+let ``taskSeq builder should handle while loops`` () = task {
+    let seq = taskSeq {
+        let mutable i = 0
+        while i < 3 do
+            yield i
+            i <- i + 1
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [0; 1; 2]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle match expressions`` () = task {
+    let getValue x = 
+        match x with
+        | 1 -> "one"
+        | 2 -> "two"
+        | _ -> "other"
+    
+    let seq = taskSeq {
+        for i in 1..3 do
+            yield getValue i
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal ["one"; "two"; "other"]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle complex async computations`` () = task {
+    let asyncComputation x = task {
+        do! Task.Delay(1)
+        return x * x
+    }
+    
+    let seq = taskSeq {
+        for i in 1..3 do
+            let! squared = asyncComputation i
+            yield squared
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [1; 4; 9]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle cancellation token propagation`` () = task {
+    use cts = new CancellationTokenSource()
+    cts.CancelAfter(100)
+    
+    let seq = taskSeq {
+        for i in 1..1000 do
+            do! Task.Delay(10, cts.Token)
+            yield i
+    }
+    
+    let asyncEnumerator = seq.GetAsyncEnumerator(cts.Token)
+    
+    let testAction() = task {
+        let mutable count = 0
+        let mutable hasMore = true
+        
+        while hasMore do
+            let! moveNext = asyncEnumerator.MoveNextAsync()
+            hasMore <- moveNext
+            if hasMore then count <- count + 1
+        
+        return count
+    }
+    
+    // Should be cancelled before reaching 1000 items
+    let ex = Assert.ThrowsAsync<OperationCanceledException>(fun () -> testAction())
+    let! _ = ex
+    ()
+}
+
+[<Fact>]
+let ``taskSeq builder should handle empty yield! with empty sequence`` () = task {
+    let seq = taskSeq {
+        yield 1
+        yield! TaskSeq.empty<int>
+        yield 2
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [1; 2]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle multiple yield! operations`` () = task {
+    let seq1 = taskSeq { yield 1; yield 2 }
+    let seq2 = taskSeq { yield 3; yield 4 }
+    
+    let combined = taskSeq {
+        yield 0
+        yield! seq1
+        yield! seq2
+        yield 5
+    }
+    
+    let! items = TaskSeq.toListAsync combined
+    items |> should equal [0; 1; 2; 3; 4; 5]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle async functions with side effects`` () = task {
+    let mutable callCount = 0
+    
+    let asyncSideEffect () = task {
+        callCount <- callCount + 1
+        return callCount
+    }
+    
+    let seq = taskSeq {
+        let! first = asyncSideEffect()
+        yield first
+        let! second = asyncSideEffect() 
+        yield second
+    }
+    
+    let! items = TaskSeq.toListAsync seq
+    items |> should equal [1; 2]
+    callCount |> should equal 2
+}
+
+[<Fact>]
+let ``taskSeq builder should handle nested taskSeq expressions`` () = task {
+    let innerSeq x = taskSeq {
+        for i in 1..x do
+            yield i * 10
+    }
+    
+    let outerSeq = taskSeq {
+        for x in 1..2 do
+            yield! innerSeq x
+    }
+    
+    let! items = TaskSeq.toListAsync outerSeq
+    items |> should equal [10; 10; 20]
+}
+
+[<Fact>]
+let ``taskSeq builder should handle computation expression return`` () = task {
+    let seq = taskSeq {
+        if true then
+            return 42
+        else
+            yield 0
+    }
+    
+    // Should complete immediately with no items when using return
+    let! items = TaskSeq.toListAsync seq
+    items |> should be Empty
+}