perf: replace LINQ with loops in test execution hot paths (#4855)

[thomhurst]

Summary

• Replace LINQ chains (Where().ToList(), .Values.ToArray(), .Any()) with simple foreach loops in test execution hot paths to reduce allocations
• Merge two-pass filter+check patterns into single-pass loops in TestContext.Dependencies
• Pre-allocate List<Task> with known capacity in ObjectLifecycleService

Closes #4855

Changes

TUnit.Engine/Services/TestDependencyResolver.cs

• uniqueDependencies.Values.ToArray() → pre-allocated ResolvedDependency[] with manual copy (2 occurrences)
• tests.Where(t => ...).ToList() → foreach loop with conditional Add

TUnit.Core/TestContext.Dependencies.cs

• GetTests(predicate): merged .Where(predicate).ToList() + .Any(x => x.Result == null) two-pass into single-pass foreach loop
• GetTests(testName) and GetTests(testName, classType): removed redundant .ToList() on TestContext[] return; replaced .Any() check with foreach loop

TUnit.Engine/Services/ObjectLifecycleService.cs

• new List<Task>() → new List<Task>(objectsAtDepth.Count) to pre-allocate with known capacity

Test plan

• dotnet build TUnit.Engine/TUnit.Engine.csproj — builds successfully (0 warnings, 0 errors)
• dotnet build TUnit.Core/TUnit.Core.csproj — builds successfully (0 warnings, 0 errors)
• CI passes all existing tests (no behavioral changes, only allocation reduction)

[claude]

Code review

No issues found. Checked for bugs and CLAUDE.md compliance.

---

This is a clean, well-executed performance optimization. A few notes on what was verified:

Correctness: All LINQ-to-loop conversions faithfully replicate the original behavior:

• The single-pass foreach with hasUnfinished flag in TestContext.Dependencies.cs correctly replicates the original two-pass .Where(predicate).ToList() + .Any(x => x.Result == null) — the flag is scoped inside the predicate check, so it only tracks unfinished tests that matched the filter.
• The manual array filling in TestDependencyResolver.cs uses uniqueDependencies.Count as both the array size and the implicit iteration count, so no IndexOutOfRangeException is possible.
• The objectsAtDepth.Count pre-allocation in ObjectLifecycleService.cs is a safe hint — List<T>.Add would resize gracefully if the count were ever wrong.

CLAUDE.md compliance:

• Rule 1 (Dual-Mode): Not applicable — all changed files operate post-metadata-collection in the execution/dependency-resolution path, which is the documented unified code path.
• Rule 4 (Performance First): The PR is directly aligned with this rule. Eliminating intermediate LINQ allocations in hot paths is exactly what the rule asks for.
• Rule 5 (AOT Compatible): No reflection introduced; no [DynamicallyAccessedMembers] needed.
• No .Result/.GetAwaiter().GetResult() blocking calls introduced.