feat(runtime): C3c - production placement cutover: both hosts on the residence conductors (routes 1+8)

Campaign P remaining-physics-divergence, placement cutover slice C3c
(docs/plans/2026-08-02-placement-cutover.md). Both production hosts now
register every initial Create through the residence + continuation-
executor + first-entry-conductor machinery (C0-C3b):

- Graphical (route 1): RegisterEntityWithInitialResidence at Create; the
  shared RuntimeFirstEntryDriveController pumps both conductors from the
  placement-receipt flow; MaterializeProjection and RebucketLiveEntity
  are presentation-only while a residence is ACTIVE (ExecutorCompleted is
  the presentation-binding receipt); post-residence entities take the
  full legacy path including the prepare_to_enter_world clock edges.
  PlayerModeController attaches presentation to the Runtime-published
  controller; its legacy resolve/step-heights/host-construction path is
  deleted; presentation-only rollback (retail has no entry-flow rollback).
- Headless (route 8): OnSpawned registers with residence when a drive
  exists; content-less sessions keep the pre-flip direct registration;
  SynchronizeLocalPlayer/CreateController/ApplySetupStepHeights deleted;
  prepared-collision read failure is a typed AwaitingCollisionSource
  retry; far remotes outside the service window complete celless.
- RuntimeLocalPlayerMovementState.Controller setter sealed internal; all
  controller mutation flows through the publication lifecycle.

Fix slices landed within this cutover, each dual-gated:
- F1: live movement-stat/server-physics application routed through the
  Runtime ownership seam (post-logout ingest crash on the retired
  controller eliminated; RuntimeMovementSkillProjection deleted).
- F2: login activation wedge - collision-admission prefix gate factored
  out of the seal (reentrant-commit RejectedAuthority), rearm generation
  identity corrected, PlayerModeAutoEntry requires the Runtime-published
  controller (world reveal can no longer seal unmaterialized).
- F3: landblock-prefix 0-sentinel replaced by explicit absent-id guards;
  map-corner landblocks (grid row/col 0) fully legal through admission,
  park/rearm/retire, quiescence, and outdoor shadow seeds.
- F5: local-player first-entry ground contact seeded by the shared
  SpawnPlacementSettler (moved App->Core) at FinalizeActivation - the
  retail first-gravity-frame touch (enter_world 0x00516170 carries no
  seed); the legacy unconditional force-seed is overwritten by a real
  floor-found contact; airborne spawns stay airborne; outbound contact
  bit verified end-to-end. Fixes the standing-cast 'You can't do that
  while in the air!' rejections.
- R1 (dual-review round): login constraint leash armed at the committed
  placement (HandleReceivedPosition 0x00453FD0 analog); register rows
  AD-61 (settle-timing compression now covering the local player) and
  AD-42 (repointed off the deleted resolve split) in this commit;
  residence-conversion owner API; wire-landblock guards; drive-pending
  ledger in IsConverged; route attach/detach latch; executor-drain drift
  model documented + source-pinned.

Gates: Runtime 1,003, App 4,039/3 skips, Headless 79, complete solution
10,816/0 failed/4 skips (Release, -m:1); connected lifecycle/reconnect
gate PASS (logs/connected-world-gate-20260802-175401; graceful exits,
world-visible, zero airborne rejections). The nine-stop soak remains red
for the pre-existing 6b28ff99 whole-world collision-clone throughput
regression (attributed with evidence; scheduled as its own slice before
C5). Dual Opus reviews (retail-conformance + adversarial): delta PASS.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/AcDream.App/Net/LiveMovementStatsApplier.cs

@@ -0,0 +1,86 @@
+using AcDream.Runtime.Gameplay;
+
+namespace AcDream.App.Net;
+
+/// <summary>
+/// C3c-F1 (2026-08-02): the App half of the movement-stats application
+/// seam. Every server stat recompute (skills, burden, stamina, PK status —
+/// the character-bindings <c>OnSkillsUpdated</c>/<c>OnMovementStatsUpdated</c>
+/// callbacks) routes through
+/// <see cref="RuntimeLocalPlayerMovementState.ApplyCharacterMovementStats"/>;
+/// App holds no controller reference and performs no direct configuration
+/// mutation. A recompute displaced past session teardown (the post-logout
+/// inbound-Create ingest chain that crashed the connected lifecycle gate)
+/// observes a typed dropped outcome and is logged under the existing
+/// player diagnostics instead of faulting the session.
+/// </summary>
+/// <remarks>
+/// Stuck-cast fix (2026-07-30): retail fires
+/// <c>CPhysicsObj::report_exhaustion</c> from exactly ONE site —
+/// <c>CommandInterpreter::HandleExhaustion</c> (0x006b3c70), a
+/// notification-handler vtable slot invoked on the stamina-exhaustion
+/// EVENT — not on every vitals refresh. The P1 wiring called
+/// <c>ReportExhaustion()</c> on EVERY movement-stats application
+/// (every stamina regen/drain tick), and each call re-dispatches the
+/// current movement state through the animation sink — truncating any
+/// in-flight action animation (cast gestures wedged mid-play; the
+/// diagnostic session showed 490 spurious stance re-queues). The
+/// re-apply fires only when the exhausted state (stamina == 0)
+/// actually TRANSITIONS, matching retail's event semantics. Skill/
+/// burden changes still reach <c>PlayerWeenie</c> immediately through
+/// the owner seam — the next natural dispatch picks up the new rates,
+/// exactly as retail. The edge is observed for dormant applications too
+/// (the event fired; a player not yet in world has no movement to
+/// re-dispatch, and activation starts movement from the already-current
+/// stamina gate), but dispatched only on a live controller.
+/// </remarks>
+internal sealed class LiveMovementStatsApplier(
+    RuntimeLocalPlayerMovementState movement,
+    RuntimeMovementSkillState skills,
+    Action<string> log)
+{
+    private readonly RuntimeLocalPlayerMovementState _movement = movement
+        ?? throw new ArgumentNullException(nameof(movement));
+    private readonly RuntimeMovementSkillState _skills = skills
+        ?? throw new ArgumentNullException(nameof(skills));
+    private readonly Action<string> _log = log
+        ?? throw new ArgumentNullException(nameof(log));
+    private readonly StaminaExhaustionEdgeTracker _staminaExhaustion = new();
+
+    /// <summary>
+    /// Forgets the retiring character/session exhaustion baseline; the next
+    /// generation's first sample must not synthesize an edge.
+    /// </summary>
+    public void Reset() => _staminaExhaustion.Reset();
+
+    public RuntimeMovementStatsApplication Apply(string reason)
+    {
+        RuntimeMovementStatsApplication outcome =
+            _movement.ApplyCharacterMovementStats(_skills);
+        switch (outcome)
+        {
+            case RuntimeMovementStatsApplication.DroppedNoController:
+            case RuntimeMovementStatsApplication.DroppedIncompleteSnapshot:
+                // Byte-identical to the pre-F1 ApplyTo=false silent skip.
+                return outcome;
+            case RuntimeMovementStatsApplication.DroppedDisplacedController:
+                _log(
+                    $"player: dropped displaced movement {reason} — the "
+                    + "Runtime movement controller is terminal");
+                return outcome;
+        }
+
+        RuntimeMovementSkillSnapshot snapshot = _skills.Snapshot;
+        if (_staminaExhaustion.Observe(snapshot.CurrentStamina)
+            && outcome is RuntimeMovementStatsApplication.AppliedLive)
+        {
+            _movement.ReportExhaustion();
+        }
+
+        _log(
+            $"player: applied server movement {reason} "
+            + $"run={snapshot.RunSkill} jump={snapshot.JumpSkill} "
+            + $"burden={snapshot.Burden:F2} stamina={snapshot.CurrentStamina}");
+        return outcome;
+    }
+}