fix(G.3): pre-collapse dungeon streaming at login/teleport — kill the login FPS ramp (#135)

On login (or teleport) into a dungeon, FPS started ~10 and climbed over ~30 s.
Root cause: the dungeon "collapse" (which shrinks the 25x25 streaming window to
the player's single dungeon landblock — AC dungeons have no neighbours) only
fires once the per-frame `insideDungeon` gate reads true, and that gate keys on
the physics CurrCell, which isn't set until the player is PLACED, which waits for
the dungeon landblock to hydrate. So during the whole hydration window NormalTick
bootstraps the full window — ~24 unrelated ocean-grid neighbour dungeons + their
~19k entities each — and the collapse only mops them up afterward. That mop-up is
the ramp.

Fix: trigger the SAME collapse early, the instant we recenter the streaming center
onto a sealed dungeon cell, before the first NormalTick.

- StreamingController.PreCollapseToDungeon(cx,cy): fires EnterDungeonCollapse
  early (idempotent). The expensive neighbour window is never enqueued.
- GameWindow.IsSealedDungeonCell(cellId): reads the EnvCell dat SeenOutside flag
  (CurrCell is null pre-placement) — the same flag ObjCell.SeenOutside and the
  per-frame gate use, so the early decision matches the eventual one. Distinguishes
  a real dungeon from a cottage/inn interior (SeenOutside → keeps its outdoor
  surround). Excludes the 0xFFFE/0xFFFF structural shell ids so an outdoor spawn id
  can't type-confuse a LandBlock record as an EnvCell.
- Hooks: OnLiveEntitySpawnedLocked (login) + OnLivePositionUpdated (teleport).
- Observer robustness: during a teleport PortalSpace hold the streaming observer
  follows the recentered destination, not the frozen pre-teleport position (which
  could drift >=2 landblocks off and trip ExitDungeonExpand). And
  _lastLivePlayerLandblockId is now filtered to the player guid (resolves the
  Phase A.1 TODO) so a stray NPC UpdatePosition can't drift the login-hold observer
  off the dungeon.

Faithful EARLY trigger of the existing AP-36 collapse mechanism, not a new
workaround — AP-36 amended in the same commit. Adversarially reviewed across
timing / threading / faithfulness lenses; 5 new tests including the real runtime
ordering (Tick bootstraps, then PreCollapse cancels). Core suite green (1463).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

tests/AcDream.Core.Tests/Streaming/StreamingControllerDungeonGateTests.cs

@@ -147,6 +147,100 @@ public class StreamingControllerDungeonGateTests
         Assert.Contains(Encode(0, 7), h.Unloads); // stale dungeon block, outside new window
     }
 
+    [Fact]
+    public void PreCollapse_BeforeAnyTick_LoadsOnlyDungeon_NeverBootstrapsWindow()
+    {
+        // #135: at a dungeon login/teleport we pre-collapse the instant we recenter,
+        // BEFORE the first Tick. The full 25×25 neighbor window must NEVER be enqueued
+        // — only the single dungeon landblock loads.
+        var h = Make();   // empty state — nothing resident, _region is null
+
+        h.Ctrl.PreCollapseToDungeon(0, 7);
+
+        Assert.Single(h.Loads);                                  // exactly one load
+        Assert.Equal(Encode(0, 7), h.Loads[0].Id);              // the dungeon landblock
+        Assert.Equal(LandblockStreamJobKind.LoadNear, h.Loads[0].Kind);
+        Assert.DoesNotContain(h.Loads, l => l.Kind == LandblockStreamJobKind.LoadFar);
+    }
+
+    [Fact]
+    public void PreCollapse_AfterBootstrapTick_CancelsWindow_UnloadsResidentNeighbors_KeepsDungeon()
+    {
+        // The REAL runtime ordering at a dungeon login: the per-frame streaming Tick
+        // runs FIRST and bootstraps the full 25×25 window, THEN the spawn handler fires
+        // PreCollapseToDungeon. The pre-collapse must cancel the queued window loads
+        // (_clearPendingLoads) and unload any neighbor that already finished streaming.
+        var h = Make();
+
+        h.Ctrl.Tick(0, 7, insideDungeon: false);   // frame 1: NormalTick bootstraps the window
+        Assert.True(h.Loads.Count > 1);            // the full window was enqueued
+
+        // Simulate neighbor landblocks that finished loading during the bootstrap,
+        // before the collapse edge.
+        h.State.AddLandblock(MakeLb(0, 7));        // the dungeon landblock itself
+        h.State.AddLandblock(MakeLb(0, 8));        // a neighbor ocean dungeon that loaded
+        h.State.AddLandblock(MakeLb(1, 7));        // another neighbor
+        h.Loads.Clear();
+        h.Unloads.Clear();
+
+        h.Ctrl.PreCollapseToDungeon(0, 7);
+
+        Assert.Equal(1, h.ClearCalls());                 // queued window loads cancelled
+        Assert.Contains(Encode(0, 8), h.Unloads);        // resident neighbor unloaded
+        Assert.Contains(Encode(1, 7), h.Unloads);
+        Assert.DoesNotContain(Encode(0, 7), h.Unloads);  // dungeon landblock kept
+    }
+
+    [Fact]
+    public void PreCollapse_ThenHoldTicksWithStaleObserver_StaysCollapsed()
+    {
+        // After pre-collapse the player is held (CurrCell still null → insideDungeon
+        // false) while the dungeon hydrates. A stale observer that is the SAME dungeon
+        // landblock must keep streaming collapsed — no full-window reload.
+        var h = Make();
+        h.Ctrl.PreCollapseToDungeon(0, 7);
+        h.Loads.Clear();
+        h.Unloads.Clear();
+
+        h.Ctrl.Tick(0, 7, insideDungeon: false);   // hold frame: not placed yet
+
+        Assert.Empty(h.Loads);     // no neighbor window
+        Assert.Empty(h.Unloads);
+    }
+
+    [Fact]
+    public void PreCollapse_IsIdempotent_OnSameLandblock()
+    {
+        // A re-sent player spawn / a same-frame double call must not re-clear or
+        // re-enqueue.
+        var h = Make();
+        h.Ctrl.PreCollapseToDungeon(0, 7);
+        h.Loads.Clear();
+
+        h.Ctrl.PreCollapseToDungeon(0, 7);
+
+        Assert.Equal(1, h.ClearCalls());   // clear fired only on the first collapse
+        Assert.Empty(h.Loads);             // no second dungeon load
+    }
+
+    [Fact]
+    public void PreCollapse_ThenPlaced_InsideDungeonTick_StaysCollapsed()
+    {
+        // When placement finally fires, the per-frame Tick(insideDungeon: true) sees
+        // the same collapsed landblock and holds — no re-collapse churn.
+        var h = Make();
+        h.State.AddLandblock(MakeLb(0, 7));        // dungeon landblock finished loading
+        h.Ctrl.PreCollapseToDungeon(0, 7);
+        h.Loads.Clear();
+        h.Unloads.Clear();
+
+        h.Ctrl.Tick(0, 7, insideDungeon: true);    // placed: gate now fires
+
+        Assert.Equal(1, h.ClearCalls());           // no second clear
+        Assert.Empty(h.Loads);
+        Assert.DoesNotContain(Encode(0, 7), h.Unloads);
+    }
+
     [Fact]
     public void NormalOutdoorTick_Unchanged_NoCollapseNoClear()
     {