engine cleanup passes 4-7 + multi-instancing ambient rip

Squashes 146 commits from battle-engine-extraction. Net: 2,045 files changed,
+11,896 / -158,687 lines. Ships engine passes 4-7 (dead-code cull, view-layer
stub, receive-path shrink) plus the Phase-5 AsyncLocal ambient deletion that
turns concurrent battles into a type-system property rather than a scope
contract.

## What landed

**Passes 4-7 (chunks 1-34):** Extended the Phase-4 const-false collapse into a
cascading cull across the skill graph, view layer, and receive-path periphery.
Six mode flags (IsWatchBattle/IsReplayBattle/IsAdmin/IsAdminWatch/IsPuzzleQuest/
IsAINetwork) became `const false`, every guarded block deleted. Field*.cs
subclass ctors + BackGroundBase + ObjectChecker culled to no-ops. Mulligan
family reworked to take a mgr param through IMulliganMgr.InitMulligan.
Emotion/Recovery/Resource clusters null-stubbed. Prediction/OperationSimulator/
skill filters converted from static ambient reads to per-mgr reads via
SkillPrm.ownerCard.SelfBattlePlayer.BattleMgr / ins.BattleMgr / this.BattleMgr.

**Phase-5 ambient rip (chunks 35-47):** Deleted BattleAmbient / BattleAmbient-
Context / TestBattleScope in full. Every per-battle mutable slot now lives on
the mgr instance itself:
  mgr.InstanceIsForecast / InstanceIsRandomDraw / InstanceRecoveryInfo /
  InstanceViewerId / InstanceNetworkAgent / GameMgr
BattleManagerBase.GetIns() returns null unconditionally; the residual static
flags + 3 façades (Certification.ViewerId, Data.BattleRecoveryInfo,
ToolboxGame.RealTimeNetworkAgent) are null-tolerant defaults kept for the
handful of engine-internal readers that still reference their types. Zero
BattleAmbient references anywhere in engine + node + tests.

Added pre-seeded GameMgr ctor overload threaded through the mgr chain
(BattleManagerBase → SingleBattleMgr / NetworkBattleManagerBase → NetworkStandard-
BattleMgr → HeadlessBattleMgr / HeadlessNetworkBattleMgr). Fixtures build a
GameMgr, seed it via HeadlessEngineEnv.SeedCharaIds/SeedNetUser, and pass it
to the mgr's ctor — no ambient reach.

Node side (SVSim.BattleNode/SessionBattleEngine): _ctx replaced with a plain
GameMgr field; 34 `using var _ambient = BattleAmbient.Enter(_ctx)` scope wraps
ripped from every accessor and mutator; EngineGlobalInit.WirePerSessionGameMgr
takes GameMgr as a param and runs from SessionBattleEngine.SetupInternal
BEFORE mgr construction.

Test side: TestBattleScope deleted; 18 fixture [SetUp]s migrated to
`HeadlessEngineEnv.EnsureProcessGlobals()`; MultiInstanceEngineTests rewritten
around per-mgr construction (GetIns() → null is the pinned invariant).

## Regression fixes

- **chunk-48** (MulliganCtrl): chunk-35's `= null` stubs on card lookups broke
  the live receive-driven Deal path (BattlePlayerBase.DrawCard NRE'd downstream
  of NetworkPlayerMulliganCtrl.StartMulliganVfx). Restored the three lookups
  via `_battlePlayer.BattleMgr.GetBattleCardIdx`. Engine tests were satisfied
  by the WireMulliganPhase seam; unit tests exposed the live-path gap.

## Ship state

- SVSim.BattleEngine.Tests: 56/56 pass, 2 skip
- SVSim.UnitTests: 1554/1554 pass (was 1523/31-fail before chunk 48)
- Solution build: 0 source warnings (40 pre-existing NU1902 MessagePack CVEs
  in SVSim.EmulatedEntrypoint, unrelated)
- Sequential PVP smoke: verified live (two back-to-back battles, no regression
  on cleanup/spinup)
- Concurrent PVP smoke: verified live

Adds tools/engine-port/ClosureAnalyzer/ — the Roslyn transitive-type-closure
analyzer needed to make future cascade cleanup safe (per feedback memory
"Engine cleanup needs closure tool" from the 2026-06-28 pass-3 failure).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

SVSim.BattleEngine.Tests/MultiInstanceEngineTests.cs

@@ -2,18 +2,18 @@
 using System.Linq;
 using System.Threading.Tasks;
 using NUnit.Framework;
-using SVSim.BattleEngine.Ambient;
 using SVSim.BattleNode.Sessions.Engine;
 
 namespace SVSim.BattleEngine.Tests;
 
-/// <summary>The forcing-function tests for the multi-instancing migration (Task 8). Each engine
-/// instance carries its OWN <see cref="BattleAmbientContext"/> internally (SessionBattleEngine
-/// constructs a per-session ctx in its field initializer and enters it on every Setup/Receive/
-/// read), so two engines on two tasks must resolve independently — no shared "current mgr",
-/// "current GameMgr", or "current viewer id" state. The stress test pins
-/// parallel-equals-sequential to catch any residual contamination (which would manifest as a
-/// life/PP/hand-count mismatch between the parallel and sequential runs).</summary>
+/// <summary>Forcing-function tests for the multi-instancing migration. After the chunk-46/47
+/// ambient rip, per-battle mutable state (IsForecast/IsRandomDraw/RecoveryInfo/ViewerId/
+/// NetworkAgent + GameMgr) lives on the mgr instance itself; there is no ambient at all,
+/// no "current mgr / current GameMgr" static gate. Two engines on two tasks resolve
+/// independently because their mgrs are different objects, full stop — this fixture pins
+/// parallel-equals-sequential to catch any residual contamination through the not-yet-culled
+/// static accumulators (Wizard.LocalLog trace SB, Unity Resources cache — both already
+/// thread-safe).</summary>
 [TestFixture, Parallelizable(ParallelScope.All)]
 public class MultiInstanceEngineTests
 {
@@ -34,13 +34,9 @@ public class MultiInstanceEngineTests
         var taskB = Task.Run(() => DriveBasicTurns(engineB));
         await Task.WhenAll(taskA, taskB);
 
-        // Pin the engines' post-Setup state to concrete starting values: LeaderLife=20 (InitLeaderLife's
-        // DefaultLeaderLife, applied by SessionBattleEngine.Setup), Pp=0 (pre-first-turn, no PP refill
-        // has run), HandCount=0 (Setup builds the deck/leader graph but doesn't deal an opening hand —
-        // mulligan/draw happens once a turn-start phase runs, which DriveBasicTurns doesn't trigger).
-        // Both engines must report the SAME starting state regardless of distinct masterSeeds, which is
-        // the cross-contamination property under test: ambient isolation means neither engine's reads
-        // can leak into the other's seat lookups.
+        // Pin the engines' post-Setup state to concrete starting values. Both engines must
+        // report the SAME starting state regardless of distinct masterSeeds, which is the
+        // cross-contamination property under test.
         Assert.That(engineA.LeaderLife(true), Is.EqualTo(20));
         Assert.That(engineB.LeaderLife(true), Is.EqualTo(20));
         Assert.That(engineA.Pp(true), Is.EqualTo(0));
@@ -56,13 +52,6 @@ public class MultiInstanceEngineTests
         for (int i = 0; i < n; i++)
             inputs[i] = (1000 + i, HeadlessEngineEnv.SampleDeck(), HeadlessEngineEnv.SampleDeck());
 
-        // Setup AND Drive both parallelize: the residual decomp-origin static accumulators
-        // (Wizard.LocalLog._lastTraceLogStringBuilder etc.) and the Unity Resources shim
-        // cache are now thread-safe (static lock / ConcurrentDictionary), so two engines
-        // constructing in parallel no longer corrupts shared scratch state. The full
-        // construct-then-read pipeline runs concurrently per task and the result still
-        // pins to the sequential baseline — that is the cross-contamination property
-        // under test (ambient isolation + safe shared statics).
         var parallel = await Task.WhenAll(inputs.Select(input => Task.Run(() =>
         {
             var e = new SessionBattleEngine();
@@ -84,10 +73,12 @@ public class MultiInstanceEngineTests
     }
 
     [Test]
-    public void GameMgr_GetIns_WithoutScope_Throws()
+    public void BattleManagerBase_GetIns_Always_Null()
     {
-        Assert.That(BattleAmbient.Current, Is.Null);
-        Assert.Throws<System.InvalidOperationException>(() => GameMgr.GetIns());
+        // Post-chunk-46 ambient rip: GetIns() has no scope-based mechanism; every engine consumer
+        // was converted to per-mgr instance reads, and the residual static returns null so its
+        // ?. cascade landing in the 3 façades / IsForecast+IsRandomDraw returns their defaults.
+        Assert.That(BattleManagerBase.GetIns(), Is.Null);
     }
 
     private static void DriveBasicTurns(SessionBattleEngine e)