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/Coverage/CleanupRegressionTests.cs

@@ -0,0 +1,43 @@
+extern alias engine;
+using NUnit.Framework;
+using System.Reflection;
+
+namespace SVSim.BattleEngine.Tests.Coverage;
+
+/// <summary>Regression backstop for the engine shim cleanup. Asserts every type we
+/// deleted in Tasks 9-15 of docs/superpowers/plans/2026-06-27-engine-shim-cleanup.md
+/// stays deleted. If a rebase or merge accidentally re-introduces one, this test
+/// fails loudly.</summary>
+[TestFixture]
+public class CleanupRegressionTests
+{
+    private static readonly string[] DeletedFqns = new[]
+    {
+        // Task 9 — DEAD-ORPHAN sweep (commit 119bf77)
+        "Wizard.AIBarrierGlobal",
+
+        // Task 10 — *Vfx.cs sweep (commit 3235f47)
+        "Wizard.Battle.Player.ClassCharacter.SkinEffectVfx",
+        "Wizard.Battle.Player.Emotion.Debug722006NullVfx",
+
+        // Task 12 — *Page.cs sweep (commit b3e2df2)
+        "Wizard.Bingo.BingoPage",
+        "Wizard.Lottery.LotteryPage",
+        "Wizard.Scripts.Network.Data.TaskData.BuildDeckPurchase.BuildDeckPurchasePage",
+        "Wizard.StorySelectPage",
+
+        // Task 13 — *Window.cs sweep (commit 92b6bf6)
+        "Wizard.CardSleeveDetailWindow",
+        "Wizard.ClassSkinDetailWindow",
+        "Wizard.OptionSettingWindow",
+        "Wizard.Scripts.Network.Data.TaskData.BuildDeckPurchase.BuildDeckDetailWindow",
+    };
+
+    [TestCaseSource(nameof(DeletedFqns))]
+    public void DeletedType_StaysDeleted(string fqn)
+    {
+        var asm = typeof(engine::BattleManagerBase).Assembly;
+        Assert.That(asm.GetType(fqn), Is.Null,
+            $"Type {fqn} was deleted in the engine shim cleanup (see plan Tasks 9-15) and must not be re-introduced.");
+    }
+}

SVSim.BattleEngine.Tests/Coverage/CoverageRecorder.cs

@@ -0,0 +1,72 @@
+extern alias engine;
+using System.Collections.Concurrent;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using HarmonyLib;
+
+namespace SVSim.BattleEngine.Tests.Coverage;
+
+/// <summary>Harmony-prefix-based method-invocation logger over SVSim.BattleEngine.dll.
+/// Idempotent: Install is safe to call from every fixture's [OneTimeSetUp]; only the first
+/// call patches.</summary>
+public static class CoverageRecorder
+{
+    private static readonly ConcurrentDictionary<string, byte> _hit = new();
+    private static readonly Harmony _h = new("svsim.engine.coverage");
+    private static bool _installed;
+    private static readonly object _gate = new();
+
+    public static int HitCount => _hit.Count;
+
+    public static void Reset() => _hit.Clear();
+
+    public static void Install()
+    {
+        lock (_gate)
+        {
+            if (_installed) return;
+            _installed = true;
+        }
+
+        var asm = typeof(engine::BattleManagerBase).Assembly;
+        var prefix = AccessTools.Method(typeof(CoverageRecorder), nameof(Hit));
+        var hm = new HarmonyMethod(prefix);
+
+        foreach (var t in asm.GetTypes())
+        {
+            var ns = t.FullName ?? string.Empty;
+            // Only engine + shim types — skip framework/3rd-party that happens to be co-located.
+            if (!ns.StartsWith("SVSim.BattleEngine.") &&
+                !ns.StartsWith("Wizard.") &&
+                !ns.StartsWith("Cute.") &&
+                !ns.StartsWith("Toolbox.") &&
+                !ns.StartsWith("UnityEngine.")) continue;
+            if (t.IsGenericTypeDefinition) continue;
+
+            var members = t.GetMethods(BindingFlags.Instance | BindingFlags.Static |
+                                       BindingFlags.Public   | BindingFlags.NonPublic |
+                                       BindingFlags.DeclaredOnly);
+            foreach (var m in members)
+            {
+                if (m.IsAbstract) continue;
+                if (m.ContainsGenericParameters) continue;
+                if (m.GetMethodBody() is null) continue;
+                try { _h.Patch(m, prefix: hm); } catch { /* generic/inlined; skipped */ }
+            }
+        }
+    }
+
+    public static void Dump(string path)
+    {
+        Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+        File.WriteAllLines(path, _hit.Keys.OrderBy(k => k));
+    }
+
+    private static void Hit(MethodBase __originalMethod)
+    {
+        var t = __originalMethod.DeclaringType;
+        if (t is null) return;
+        _hit.TryAdd($"{t.FullName}.{__originalMethod.Name}", 0);
+    }
+}

SVSim.BattleEngine.Tests/Coverage/CoverageRecorderTests.cs

@@ -0,0 +1,42 @@
+extern alias engine;
+using System.IO;
+using System.Linq;
+using NUnit.Framework;
+using SVSim.BattleEngine.Tests.Coverage;
+
+namespace SVSim.BattleEngine.Tests.Coverage;
+
+[TestFixture, NonParallelizable]
+public class CoverageRecorderTests
+{
+    [SetUp] public void SetUp() => CoverageRecorder.Reset();
+
+    [Test]
+    public void Install_RecordsAtLeastOneHit_AfterCallingAnEngineType()
+    {
+        CoverageRecorder.Install();
+        // Phase-5 chunk 47: was `BattleAmbient.Current` (deleted). Call any engine-type method
+        // with a body so the Harmony prefix records a hit; Certification.ViewerId's getter is a
+        // small non-inlined engine method that still ships (façade retained; consumers all read
+        // per-mgr now).
+        var _ = engine::Cute.Certification.ViewerId;
+        Assert.That(CoverageRecorder.HitCount, Is.GreaterThan(0));
+    }
+
+    [Test]
+    public void Dump_WritesSortedFqns_OneLineEach()
+    {
+        CoverageRecorder.Install();
+        // Phase-5 chunk 47: was `BattleAmbient.Current` (deleted). Call any engine-type method
+        // with a body so the Harmony prefix records a hit; Certification.ViewerId's getter is a
+        // small non-inlined engine method that still ships (façade retained; consumers all read
+        // per-mgr now).
+        var _ = engine::Cute.Certification.ViewerId;
+        var path = Path.Combine(Path.GetTempPath(), "coverage-recorder-test.txt");
+        CoverageRecorder.Dump(path);
+        var lines = File.ReadAllLines(path).ToList();
+        Assert.That(lines, Is.Not.Empty);
+        Assert.That(lines, Is.Ordered);
+        Assert.That(lines.All(l => l.Contains(".")), Is.True);
+    }
+}

SVSim.BattleEngine.Tests/Coverage/CoverageSetUpFixture.cs

@@ -0,0 +1,37 @@
+using System;
+using System.IO;
+using NUnit.Framework;
+using SVSim.BattleEngine.Tests.Coverage;
+
+namespace SVSim.BattleEngine.Tests;
+
+/// <summary>Assembly-level NUnit fixture. When SVSIM_COVERAGE=1, installs
+/// CoverageRecorder before any test runs and dumps the recorded FQNs after
+/// the assembly finishes. Outside SVSIM_COVERAGE=1, this fixture is a no-op
+/// — production test runs are unaffected.</summary>
+[SetUpFixture]
+public class CoverageSetUpFixture
+{
+    public static bool IsEnabled =>
+        Environment.GetEnvironmentVariable("SVSIM_COVERAGE") == "1";
+
+    public static string DumpPath =>
+        Path.Combine(TestContext.CurrentContext.TestDirectory,
+                     "..", "..", "..", "obj", "coverage",
+                     "SVSim.BattleEngine.Tests.live.txt");
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        if (!IsEnabled) return;
+        CoverageRecorder.Install();
+    }
+
+    [OneTimeTearDown]
+    public void OneTimeTearDown()
+    {
+        if (!IsEnabled) return;
+        CoverageRecorder.Dump(DumpPath);
+        TestContext.Progress.WriteLine($"[coverage] dumped {CoverageRecorder.HitCount} FQNs to {DumpPath}");
+    }
+}

SVSim.BattleEngine.Tests/Coverage/CoverageSetUpFixtureTests.cs

@@ -0,0 +1,34 @@
+using NUnit.Framework;
+using SVSim.BattleEngine.Tests;
+
+namespace SVSim.BattleEngine.Tests.Coverage;
+
+[TestFixture]
+public class CoverageSetUpFixtureTests
+{
+    [Test]
+    public void DumpPath_IsObjCoverageBattleEngineLiveTxt()
+    {
+        Assert.That(
+            CoverageSetUpFixture.DumpPath,
+            Does.EndWith("obj/coverage/SVSim.BattleEngine.Tests.live.txt")
+                .Or.EndWith(@"obj\coverage\SVSim.BattleEngine.Tests.live.txt"));
+    }
+
+    [Test]
+    public void IsEnabled_ReflectsEnvVar()
+    {
+        var prior = System.Environment.GetEnvironmentVariable("SVSIM_COVERAGE");
+        try
+        {
+            System.Environment.SetEnvironmentVariable("SVSIM_COVERAGE", "1");
+            Assert.That(CoverageSetUpFixture.IsEnabled, Is.True);
+            System.Environment.SetEnvironmentVariable("SVSIM_COVERAGE", null);
+            Assert.That(CoverageSetUpFixture.IsEnabled, Is.False);
+        }
+        finally
+        {
+            System.Environment.SetEnvironmentVariable("SVSIM_COVERAGE", prior);
+        }
+    }
+}