fix(physics): TS-23 - plumb real PK/PKLite/Impenetrable mover flags

Campaign P Slice P3 item 3. The wire parse (CreateObject's
PublicWeenieDesc._bitfield), the decode (EntityCollisionFlagsExt.
FromPwdBitfield), the per-GUID storage (ClientObjectTable.
PublicWeenieBitfield), and the exemption logic (CollisionExemption.
ShouldSkip) all already existed and were already correct -- every
mover-flags call site just fed a GUID-prefix IsPlayer heuristic instead
of the real per-entity PK/PKLite/Impenetrable state (retail
OBJECTINFO::init 0x0050cf30 state |= 0x80/0x800/0x1000).

Port:
- EntityCollisionFlagsExt.ToMoverState translates the decoded PWD
  bit-space into the ObjectInfoState bit-space FindObjCollisions
  actually reads -- two different numberings that must not be
  confused. Deliberately does not translate IsPlayer (every call site
  already derives that correctly from its own GUID heuristic per
  #184 Slice 2b).
- EntityCollisionFlagsExt.ResolveMoverPvpState is the one shared
  ClientObjectTable-backed lookup (guid -> ObjectInfoState), replacing
  what would otherwise have been three separate inline copies across
  GameWindow/LivePresentationComposition/RemoteTeleportController.
- Threaded as a new optional moverPvpState parameter through
  RuntimeRemotePhysicsUpdater.Tick/TickHidden and
  RuntimeOrdinaryPhysicsUpdater.TryBegin (default None preserves every
  pre-P3 caller unchanged), and as PlayerMovementController.OwnPvpFlags
  for the local player's own two resolve call sites.
- TS-23 section 12b: PlayerWeenie.JumpStaminaCost's pk parameter now
  reads the real PlayerKillerStatus(0x86)/LastPkAttackTimestamp(0x91)
  pair against retail's 20-second recency window
  (pkStatus in {4, 0x40} && (timestamp + 20.0) >= now), replacing the
  P1 hardcoded false. RuntimeMovementSkillState/Snapshot and
  LiveSessionEventRouter.RecomputePvpStatus push both the PWD bitfield
  and the PlayerKillerStatus pair reactively, riding the SAME
  ClientObject event triggers RecomputeBurden already uses.
- A conformance test caught a genuine precision bug in the first
  PK-timer clock choice: DateTimeOffset.UtcNow's Unix-epoch seconds
  (~1.7 billion) loses ~128 seconds of precision in a 32-bit float,
  silently swallowing the entire 20-second window. Switched to
  Environment.TickCount64 (small, monotonic magnitude) -- also the more
  retail-plausible basis, since LastPkAttackTimestamp is itself a wire
  PropertyFloat and retail's Timer::cur_time is almost certainly a
  process/session-relative counter for the same precision reason, not
  an absolute epoch.

Non-PK invariant (the acceptance criterion): an entity with no
ClientObjectTable row, or a row whose PublicWeenieBitfield is null or
0, resolves to ObjectInfoState.None -- a no-op OR into moverFlags,
bit-identical to every pre-P3 caller's hardcoded value. A dedicated
test drives two real ClientObjectTable rows through
CollisionExemption.ShouldSkip and confirms PK-vs-PK collides while
PK-vs-non-PK and non-PK-vs-non-PK both stay exempt (walk through).

Register: TS-23 retired (both the collision-flags and PK-timer halves);
the stale "M2 combat must land TS-23" phase-gate note removed.

dotnet build + dotnet test (Core.Tests 4008/2 skip, Runtime.Tests
425/0, App.Tests 3968/3 skip, complete solution build) all green.

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

tests/AcDream.Core.Tests/Physics/PlayerWeenieTests.cs

@@ -141,6 +141,92 @@ public class PlayerWeenieTests
         Assert.Equal(14, cost);
     }
 
+    // ── TS-23 §12b (Campaign P Slice P3, 2026-07-30): PlayerKillerStatus/ ──
+    // ── LastPkAttackTimestamp PK-timer jump-cost bump ───────────────────────
+
+    // Matches PlayerWeenie.JumpStaminaCost's own clock exactly (see its
+    // doc remarks for why Environment.TickCount64, not an absolute epoch).
+    private static float NowSeconds() => Environment.TickCount64 / 1000f;
+
+    [Fact]
+    public void JumpStaminaCost_NeverPushed_UsesNonPkFormula_TheInvariant()
+    {
+        // THE non-PK invariant: a character whose PlayerKillerStatus was
+        // never pushed at all (every ACE default-created character, and
+        // every pre-P3 caller) must produce the exact SAME cost as before
+        // this port.
+        var pw = new PlayerWeenie(runSkill: 200, jumpSkill: 100);
+        Assert.True(pw.JumpStaminaCost(1.0f, out int cost));
+        Assert.Equal(6, cost); // ceil((0+0.5)*1*8+2) = 6, unchanged from P1
+    }
+
+    [Fact]
+    public void JumpStaminaCost_PlayerKillerStatusRetailDefault_UsesNonPkFormula()
+    {
+        // Retail InqInt's own default (8, "not a killer") with a fresh
+        // timestamp still does not qualify — pkStatus must be 4 or 0x40.
+        var pw = new PlayerWeenie(runSkill: 200, jumpSkill: 100);
+        pw.SetPlayerKillerStatus(8, NowSeconds());
+        Assert.True(pw.JumpStaminaCost(1.0f, out int cost));
+        Assert.Equal(6, cost);
+    }
+
+    [Fact]
+    public void JumpStaminaCost_PkStatusNoTimestamp_UsesNonPkFormula()
+    {
+        // pkStatus qualifies (PK), but LastPkAttackTimestamp was never
+        // pushed (retail's InqFloat "fails") — the pk flag stays false.
+        var pw = new PlayerWeenie(runSkill: 200, jumpSkill: 100);
+        pw.SetPlayerKillerStatus(4, null);
+        Assert.True(pw.JumpStaminaCost(1.0f, out int cost));
+        Assert.Equal(6, cost);
+    }
+
+    [Fact]
+    public void JumpStaminaCost_PkStatusActiveWithinWindow_UsesPkFormula()
+    {
+        var pw = new PlayerWeenie(runSkill: 200, jumpSkill: 100);
+        pw.SetPlayerKillerStatus(4, NowSeconds()); // just attacked
+        Assert.True(pw.JumpStaminaCost(1.0f, out int cost));
+        // pk branch: (int)((power + 1.0) * 100.0) = (1.0+1.0)*100 = 200
+        Assert.Equal(200, cost);
+    }
+
+    [Fact]
+    public void JumpStaminaCost_PkLiteStatusActiveWithinWindow_UsesPkFormula()
+    {
+        // BF_PKLITE_PKSTATUS decodes to the retail PKLite status code 0x40
+        // (per CACQualities::JumpStaminaCost's own comparison, §12b) — both
+        // PK(4) and PKLite(0x40) qualify identically.
+        var pw = new PlayerWeenie(runSkill: 200, jumpSkill: 100);
+        pw.SetPlayerKillerStatus(0x40, NowSeconds());
+        Assert.True(pw.JumpStaminaCost(1.0f, out int cost));
+        Assert.Equal(200, cost);
+    }
+
+    [Fact]
+    public void JumpStaminaCost_PkTimerExpired_UsesNonPkFormula()
+    {
+        // 30 seconds ago — past the 20-second recency window.
+        var pw = new PlayerWeenie(runSkill: 200, jumpSkill: 100);
+        pw.SetPlayerKillerStatus(4, NowSeconds() - 30f);
+        Assert.True(pw.JumpStaminaCost(1.0f, out int cost));
+        Assert.Equal(6, cost);
+    }
+
+    [Fact]
+    public void JumpStaminaCost_PkTimerRestoredToNeverPushed_ReturnsToNonPkFormula()
+    {
+        var pw = new PlayerWeenie(runSkill: 200, jumpSkill: 100);
+        pw.SetPlayerKillerStatus(4, NowSeconds());
+        Assert.True(pw.JumpStaminaCost(1.0f, out int cost));
+        Assert.Equal(200, cost);
+
+        pw.SetPlayerKillerStatus(null, null);
+        Assert.True(pw.JumpStaminaCost(1.0f, out int cost2));
+        Assert.Equal(6, cost2);
+    }
+
     [Fact]
     public void InqRunRate_ZeroStamina_ZeroesEffectiveSkill()
     {