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.BattleNode/Sessions/BattleSession.cs

@@ -186,10 +186,10 @@ public sealed class BattleSession
         if (A is RealParticipant rpA) rpA.Outbound.Clear();
         if (B is RealParticipant rpB) rpB.Outbound.Clear();
 
-        // Per-session BattleAmbientContext on the engine isolates per-battle state across concurrent
-        // sessions (Task 7 of multi-instancing migration), so the historical single-active-engine gate
-        // (and its matching try/finally Release) is gone — engine setup is unconditional per session,
-        // and there is no teardown obligation that must run on a throw from the participant tear-down.
+        // Per-session mgr instance (Phase-5 ambient rip, chunk 47) isolates per-battle state across
+        // concurrent sessions, so the historical single-active-engine gate (and its matching
+        // try/finally Release) is gone — engine setup is unconditional per session, and there is no
+        // teardown obligation that must run on a throw from the participant tear-down.
         await Task.WhenAll(
             A.TerminateAsync(BattleFinishReason.NormalFinish),
             B.TerminateAsync(BattleFinishReason.NormalFinish))
@@ -278,10 +278,10 @@ public sealed class BattleSession
             {
                 case NetworkBattleUri.Deal when !_engineDealFed:
                     _engineDealFed = true;
-                    _log.LogWarning("BattleSession {Bid}: DEAL DIAG BEFORE: {Diag}",
+                    _log.LogDebug("BattleSession {Bid}: DEAL diag BEFORE: {Diag}",
                         BattleId, _engine.DiagnoseDealState());
                     ShadowFeed(frame, isPlayerSeat: true, "Deal");
-                    _log.LogWarning("BattleSession {Bid}: DEAL DIAG AFTER: {Diag}",
+                    _log.LogDebug("BattleSession {Bid}: DEAL diag AFTER: {Diag}",
                         BattleId, _engine.DiagnoseDealState());
                     break;
 
@@ -338,12 +338,12 @@ public sealed class BattleSession
         if (_engineSetupAttempted) return;
         _engineSetupAttempted = true;
 
-        // Per-session BattleAmbientContext on the engine isolates per-battle state across concurrent
-        // sessions (Task 7 of multi-instancing migration), so the historical single-active-engine gate
-        // (EngineSessionGate.TryAcquire) is gone and engine setup is unconditional. A genuine setup
-        // failure still surfaces via ComputeFrames' shadow-engine try/catch (it logs + swallows so the
-        // relay never sees an engine exception, ND6), and IsReady stays false in that case so
-        // ShadowIngest/ShadowFeedServerFrames no-op for the rest of the battle.
+        // Per-session mgr instance (Phase-5 ambient rip, chunk 47) isolates per-battle state across
+        // concurrent sessions, so the historical single-active-engine gate (EngineSessionGate.TryAcquire)
+        // is gone and engine setup is unconditional. A genuine setup failure still surfaces via
+        // ComputeFrames' shadow-engine try/catch (it logs + swallows so the relay never sees an engine
+        // exception, ND6), and IsReady stays false in that case so ShadowIngest/ShadowFeedServerFrames
+        // no-op for the rest of the battle.
         //
         // Seed the engine's StableRandom with BattleSeeds.Stable(MasterSeed) — the SAME value the
         // Matched frame ships to both clients (InitBattleHandler.cs:28). The clients seed their
@@ -362,6 +362,14 @@ public sealed class BattleSession
     private void ShadowIngest(IBattleParticipant from, MsgEnvelope env)
     {
         if (!_engine.IsReady) return;
+        // Node-only handshake URIs (InitNetwork, InitBattle) have no counterpart on the engine's
+        // NetworkBattleURI enum — they're pure relay plumbing (see InitNetworkHandler /
+        // InitBattleHandler). Feeding them to the engine's MapUri throws ArgumentException that
+        // the outer try/catch swallows, but produces a per-frame warn+stack-trace for every
+        // battle setup. Skip at the ingest source rather than plumb an ignore-branch through the
+        // engine (the whole point of the shadow being separate is that node protocol changes
+        // shouldn't require engine touches).
+        if (env.Uri is NetworkBattleUri.InitNetwork or NetworkBattleUri.InitBattle) return;
         bool isPlayerSeat = ReferenceEquals(from, A);
         var r = _engine.Receive(env, isPlayerSeat);
         if (r.Diverged)