Add ParallelAsync for concurrent branch execution (DOTNET-8662)

[GarrettBeatty]

#2216

What

Adds parallel branch execution to Amazon.Lambda.DurableExecution. ParallelAsync runs N branches concurrently with configurable concurrency limits and completion policies, returning an IBatchResult<T> with per-branch status and error information. The shared IBatchResult<T> family is reused by MapAsync in Wave 2.

Public API:

Type	Purpose
IDurableContext.ParallelAsync<T>(Func[], ...)	Run unnamed branches concurrently.
IDurableContext.ParallelAsync<T>(DurableBranch<T>[], ...)	Same, but each branch carries an explicit name for traces / test inspection.
DurableBranch<T>(Name, Func)	Named-branch record.
ParallelConfig	MaxConcurrency, CompletionConfig, NestingType.
CompletionConfig	When the batch is considered complete. Factories: AllSuccessful(), FirstSuccessful(), AllCompleted(). Validated MinSuccessful / ToleratedFailureCount / ToleratedFailurePercentage (0.0–1.0).
IBatchResult<T>	Per-branch view: All / Succeeded / Failed / Started, GetResults, GetErrors, ThrowIfError, HasFailure, CompletionReason, count properties.
IBatchItem<T>	Single-branch record (Index, Name, Status, Result, Error).
BatchItemStatus	Succeeded / Failed / Started.
CompletionReason	AllCompleted / MinSuccessfulReached / FailureToleranceExceeded.
NestingType	Nested (default); Flat reserved for a follow-up PR (throws NotSupportedException today).
ParallelException	Thrown when CompletionConfig signals FailureToleranceExceeded; carries the IBatchResult<T>.

Per-branch checkpoint payloads are serialized via the ILambdaSerializer registered on ILambdaContext.Serializer — same pattern as StepAsync / RunInChildContextAsync from #2370. There are no separate reflection / AOT-safe overload pairs: the AOT story is determined entirely by which serializer the user registers with the runtime (e.g., SourceGeneratorLambdaJsonSerializer<TContext>).

How

Internal/ParallelOperation<T> orchestrates branch dispatch on top of the existing child-context plumbing from #2370:

• Branch dispatch. Each branch runs as a ChildContextOperation<T> with a deterministic ID via OperationIdGenerator.CreateChild, so concurrent branches get stable, namespaced IDs across replays. Optional MaxConcurrency is enforced with a SemaphoreSlim.
• Completion semantics. The orchestrator monitors branch completion against CompletionConfig. FirstSuccessful short-circuits as soon as one branch succeeds (remaining branches surface in Started). MinSuccessful / ToleratedFailureCount / ToleratedFailurePercentage resolve to AllCompleted, MinSuccessfulReached, or FailureToleranceExceeded via CompletionReason.
• Failure aggregation. Branch throws are captured as Failed items in IBatchResult<T>; the orchestrator only throws ParallelException when CompletionConfig signals FailureToleranceExceeded. Successful and tolerated-failure batches return normally so the user can inspect result.GetResults() / result.GetErrors().
• Cancellation safety. ParallelOperation awaits Task.WhenAll(inFlight) before disposing the semaphore so a mid-dispatch cancellation or exception lets in-flight branches settle cleanly — no orphaned tasks holding semaphore permits.
• Concurrency-safe state. ExecutionState is now thread-safe: a single lock guards reads/writes of _operations, _visitedOperations, and _isReplaying. Required so concurrent branches can replay without tearing the visited-set or seeing an inconsistent IsReplaying flag. Affects all operations — no behavioral regressions.
• Replay. Each branch's ChildContextOperation replays from its own checkpoint independently; the parent Parallel operation reconstructs the IBatchResult<T> view from the branches' terminal states.
• Reuses OperationSubTypes.Parallel and OperationSubTypes.ParallelBranch from Wave 0 (doc updates #2372).

Stacked on top of #2372.

Fixes DOTNET-8662.

Testing

31 new unit tests in ParallelOperationTests.cs and supporting fixtures:

• CompletionConfig matrix: AllSuccessful, AllCompleted, FirstSuccessful, MinSuccessful, ToleratedFailureCount, ToleratedFailurePercentage — both pass and fail thresholds.
• Concurrency: MaxConcurrency enforced via semaphore; unbounded when null; cancel-mid-dispatch leaves no orphan branches.
• Concurrent ExecutionState access regression test (parallel writers do not corrupt the visited-set).
• Replay determinism: mixed-status replay (SUCCEEDED + FAILED + STARTED), FirstSuccessful with all-fail, named vs. unnamed branches.
• IBatchResult<T> accessors and GetResults / GetErrors / ThrowIfError semantics.
• NestingType.Flat throws NotSupportedException (placeholder for follow-up).

6 new integration tests build successfully (require AWS credentials to run).

Build clean: 0 warnings, 0 errors on net8.0 and net10.0.

Out of scope (follow-up PRs)

• MapAsync — same IBatchResult<T> machinery, but driven by an input collection.
• NestingType.Flat — virtual contexts sharing a parent (~30% fewer checkpoint operations); placeholder today.
• DurableLogger replay-suppression (currently NullLogger).
• Annotations source-generator integration / [DurableExecution] attribute.
• DurableTestRunner / Amazon.Lambda.DurableExecution.Testing package.
• dotnet new lambda.DurableFunction blueprint.