fix: resolve pre-4.0 audit findings across streaming and cancellation paths

[thomhurst]

Summary

Resolves all eight pre-4.0 audit findings (#362–#369) in one change set, ahead of the v4.0 release freezing these contracts.

• Async-enumerable void path surfaces only the first exception; remaining failures are unrecoverable #362 — exception fidelity: ExecuteAsync() on the IAsyncEnumerable void processors now returns a TaskCompletionSource-backed task, so Task.Exception.InnerExceptions carries every failure (exact Task.WhenAll parity with the enumerable processors) while await still throws the first. Applied to the worker pool, parallel, batch, and one-at-a-time processors via a new internal StreamingExecution helper.
• Unbounded async-enumerable result streaming: early break blocks until all in-flight tasks finish, then swallows every failure #363 — stream abandonment: breaking out of a result stream cancels the processor's in-flight work, drains it within the 30-second disposal window, and observes failures. The void twin no longer masks a mid-enumeration source failure with an in-flight task failure — the source failure stays primary and task failures append. The bounded path enumerates the worker pool manually so cancellation fires before the pool's drain.
• Unbounded ProcessInParallel extension abandons started tasks fire-and-forget on mid-enumeration failure #364 — extension abandonment: the unbounded ProcessInParallel extension drains and observes started tasks on mid-enumeration failure, then rethrows the source exception, instead of abandoning them fire-and-forget.
• Result ordering contract silently flips between bounded and unbounded parallel streaming #365 — ordering contract: documented rather than unified (option 1 from the issue). Bounded streaming and the awaitable extension yield source order; unbounded streaming and GetResultsAsyncEnumerable() yield completion order; GetResultsAsync() yields source order. XML docs plus a new README "Result ordering" section.
• ConfigureAwait(false) gaps in SelectMany/SelectManyAsync iterators #366 — ConfigureAwait gaps: all ten WithCancellation enumerations in the SelectMany/SelectManyAsync iterator families now use ConfigureAwait(false).
• Pre-cancelled token surfaces internal ArgumentException instead of canceled tasks #367 — pre-cancelled token: building a processor with an already-cancelled token yields cancelled per-item tasks and OperationCanceledException from WaitAsync/GetResultsAsync, instead of ArgumentException naming an internal constructor parameter. The cancellation registration in ProcessorLifecycle.Start fires synchronously on the fully built instance, so the original partially-built-instance concern does not apply.
• CancelAll racing Dispose can throw ObjectDisposedException from the disposed CTS #368 — CancelAll/Dispose race: CancelAllCore catches ObjectDisposedException around the CTS cancel, matching the streaming processors' existing CancelForDisposal handling.
• Second ExecuteAsync call on a single-use streaming processor throws raw ObjectDisposedException #369 — single-use enforcement: a second ExecuteAsync call throws InvalidOperationException eagerly at the call site (result variants included — the guard is in a non-iterator wrapper); calling after disposal throws ObjectDisposedException naming the processor type.

No public API signature changes — the PublicAPI analyzer is clean and the V3 binary-compatibility tests pass. The README migration guide gains five bullets covering the behaviour changes.

Test plan

• 14 new tests across PreCancelledTokenTests, SingleUseExecutionTests, and AsyncEnumerableExceptionFidelityTests (multi-failure fidelity, source-failure primacy, early-break cancellation for bounded and unbounded streams, extension drain)
• ValidationRegressionTests.Already_Cancelled_Token_Fails_Cleanly_At_Build_Time rewritten to the new contract
• Full suite: 572 tests × net8.0 / net9.0 / net10.0, all passing (net8.0 exercises the Task.WhenEach fallback path)

Fixes #362, #363, #364, #365, #366, #367, #368, #369.

[greptile-apps]

Greptile Summary

This PR updates streaming execution and cancellation behavior before the v4 release. The main changes are:

• Preserves multiple asynchronous failures on returned tasks.
• Cancels and drains work when result streams are abandoned.
• Enforces single-use execution across streaming processors.
• Handles pre-cancelled tokens and disposal races.
• Documents result ordering and migration behavior.

Confidence Score: 5/5

This looks safe to merge.

• Purely cancelled batches now complete in the cancelled state.
• The execution guard reads disposal state after claiming execution.
• No blocking follow-up issue remains in the reviewed fixes.

Important Files Changed

Filename	Overview
EnumerableAsyncProcessor/RunnableProcessors/AsyncEnumerable/AsyncEnumerableBatchProcessor.cs	Propagates pure batch cancellation and preserves all failures from faulted batches.
EnumerableAsyncProcessor/StreamingExecution.cs	Adds shared single-use guards, completion handling, and abandoned-task observation.
EnumerableAsyncProcessor/AsyncEnumerableWorkerPool.cs	Preserves worker failures and bounds cleanup when result enumeration ends early.
EnumerableAsyncProcessor/ProcessorLifecycle.cs	Supports pre-cancelled tokens and handles concurrent cancellation-source disposal.

_{Reviews (2): Last reviewed commit: "fix: address review - guard disposal sna..." | Re-trigger Greptile}