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.Core/Physics/ShadowObjectRegistry.cs

@@ -643,12 +643,17 @@ public sealed class ShadowObjectRegistry
     private static uint DeriveOutdoorSeed(
         Vector3 worldPos, float worldOffsetX, float worldOffsetY, uint landblockId)
     {
+        // C3c-F3: only a genuinely-absent landblock id (0) has no seed —
+        // prefix 0x00000000 is landblock (0,0), the map corner, whose
+        // outdoor cells 0x00000001..0x40 are as real as any other block's.
+        // The old prefix-0 sentinel silently dropped every landblock-baked
+        // static in the corner block.
+        if (landblockId == 0u) return 0u;
         float localX = worldPos.X - worldOffsetX;
         float localY = worldPos.Y - worldOffsetY;
         int cx = (int)System.Math.Clamp(localX / 24f, 0f, 7f);
         int cy = (int)System.Math.Clamp(localY / 24f, 0f, 7f);
         uint lbPrefix = landblockId & 0xFFFF0000u;
-        if (lbPrefix == 0u) return 0u;
         // The clamp only anchors the SEED id; AddAllOutsideCells re-seats the
         // actual flood cells from the sphere centers via LandDefs.AdjustToOutside
         // (block-crossing), so an out-of-block position still floods correctly.
@@ -2120,7 +2125,16 @@ public sealed class ShadowObjectRegistry
         return false;
     }
 
-    internal bool HasLogicalOwner(uint entityId) =>
+    /// <summary>
+    /// True while <paramref name="entityId"/> owns a logical shadow
+    /// registration (suspended or live). Public since C3c: the graphical
+    /// host reports the truthful
+    /// local-player shadow disposition (authored payload vs proven
+    /// shapeless) into the Runtime first-entry activation, which
+    /// <see cref="TryPrepareSetPosition"/> validates against this exact
+    /// registry state.
+    /// </summary>
+    public bool HasLogicalOwner(uint entityId) =>
         _entityReg.ContainsKey(entityId);
 
     /// <summary>

src/AcDream.Core/Physics/SpawnPlacementSettler.cs

@@ -0,0 +1,74 @@
+using System.Numerics;
+
+namespace AcDream.Core.Physics;
+
+/// <summary>
+/// Performs the compressed first-gravity-frame settle used to establish
+/// retail Contact/OnWalkable state for a newly placed body.
+///
+/// Retail gains spawn contact from the FIRST GRAVITY FRAME, not the
+/// placement itself: <c>CPhysicsObj::enter_world</c> (0x00516170) runs
+/// <c>SetPosition</c> (find_placement validates the spot but records no
+/// touch) and every retail CPhysicsObj then simulates, falls the few
+/// centimetres onto the floor, and the transition's touch grants the
+/// contact plane + CONTACT/ON_WALKABLE. Bodies that do not run that first
+/// ordinary frame at placement (stationary remotes — #270 — and the local
+/// player's Runtime first-entry activation — C3c-F5) compress the settle
+/// here: a short downward sweep from the placed position whose touch
+/// handler produces exactly the state retail's first frame would. A sweep
+/// that finds no floor (true airborne spawn) leaves the body airborne,
+/// exactly like retail's fall.
+/// </summary>
+public static class SpawnPlacementSettler
+{
+    public const float SettleDistance = 0.5f;
+
+    public static bool TrySettle(
+        PhysicsEngine physicsEngine,
+        PhysicsBody body,
+        Vector3 worldPosition,
+        uint cellId,
+        float sphereRadius,
+        float sphereHeight,
+        ObjectInfoState moverFlags,
+        uint movingEntityId,
+        Action hitGround,
+        Action leaveGround)
+    {
+        ArgumentNullException.ThrowIfNull(physicsEngine);
+        ArgumentNullException.ThrowIfNull(body);
+        ArgumentNullException.ThrowIfNull(hitGround);
+        ArgumentNullException.ThrowIfNull(leaveGround);
+
+        if (cellId == 0)
+            return false;
+
+        ResolveResult settle = physicsEngine.ResolveWithTransition(
+            worldPosition,
+            worldPosition - new Vector3(0f, 0f, SettleDistance),
+            cellId,
+            sphereRadius,
+            sphereHeight,
+            stepUpHeight: 0.4f,
+            stepDownHeight: 0.4f,
+            isOnGround: false,
+            body,
+            moverFlags,
+            movingEntityId);
+        if (!settle.Ok || !settle.InContact)
+            return false;
+
+        body.Position = settle.Position;
+        PhysicsObjUpdate.CommitSetPositionTransition(
+            body,
+            settle.InContact,
+            settle.OnWalkable,
+            settle.CollisionNormalValid,
+            settle.CollisionNormal,
+            previousContact: false,
+            previousOnWalkable: false,
+            hitGround,
+            leaveGround);
+        return true;
+    }
+}