fix(BUG-5): unify turn-advance core (DRY), 500 rounds skip-free

Extract shared nextActiveAfter() advance core. Both nextTurn and
computeTurnOrderAfterRemoval delegate to it — single source of truth,
eliminates drift risk where one path changes and the other doesn't.

Previously two separate advance implementations computed the same
target, but any future edit to one would silently desync deact-current
advance from normal nextTurn advance.

Replay (scripts/replay-combat.js):
- Move turn-line print before mutations (event order = reality)
- Emit [pointer X→Y] lines when a mutation advances currentTurnParticipantId
- Emit [pointer X→Y wrap] when round bumps (removal-wrap case)
- Skip pointer emission for nextTurn (label=null) — already logged via turn line

Parser (scripts/analyze-turns.js):
- Parse [pointer X→Y wrap] events
- Credit pointer-target as acted (deact-current advance = turn pointer)
- Wrap pointer credits NEXT round (not current) — fixes cross-round false skip
- Drop currentRemoved special-case — pointer lines make skip check precise

Tests:
- shared/tests/turn.dry.test.js: 3 tests lock deact-current advance ==
  nextTurn advance (mid-round, inactive-skipper, wrap+round-bump). RED
  catches future drift.

Results: 500-round replay now 0 real skips, 0 double-acts (was 5+3).
Shared suite: 79 green + 1 RED (BUG-6 reorder, intentional).

shared/tests/turn.dry.test.js

@@ -0,0 +1,52 @@
+// DRY guard (BUG-5 fix): nextTurn and computeTurnOrderAfterRemoval share one
+// advance core (nextActiveAfter). Both must pick the SAME next-active target
+// for identical state. If this goes RED, the two paths drifted.
+
+'use strict';
+
+const shared = require('@ttrpg/shared');
+const { makeParticipant, startEncounter, nextTurn, toggleParticipantActive } = shared;
+
+function p(id, init, extra = {}) {
+  return makeParticipant({ id, name: id, type: 'monster',
+    initiative: init, maxHp: 100, currentHp: 100, ...extra });
+}
+function enc(ps, extra = {}) {
+  return { name:'t', participants:ps, isStarted:false, isPaused:false,
+    round:0, currentTurnParticipantId:null, turnOrderIds:[], ...extra };
+}
+
+describe('DRY: deact-current advance == nextTurn advance', () => {
+  test('mid-round: same target (not current)', () => {
+    // order a,b,c. a current. nextTurn → b. deact a → advance → b.
+    const e = enc([p('a',10),p('b',5),p('c',3)], { isStarted:true,
+      turnOrderIds:['a','b','c'], currentTurnParticipantId:'a' });
+    const nt = nextTurn(e).patch.currentTurnParticipantId;
+    const deact = toggleParticipantActive(e, 'a').patch.currentTurnParticipantId;
+    expect(deact).toBe(nt);
+    expect(deact).toBe('b');
+  });
+
+  test('mid-round with inactive skipper: same target', () => {
+    // order a,x,b,c; x inactive. a current. nextTurn → b. deact a → b.
+    const x = p('x',7,{ isActive:false });
+    const e = enc([p('a',10),x,p('b',5),p('c',3)], { isStarted:true,
+      turnOrderIds:['a','x','b','c'], currentTurnParticipantId:'a' });
+    const nt = nextTurn(e).patch.currentTurnParticipantId;
+    const deact = toggleParticipantActive(e, 'a').patch.currentTurnParticipantId;
+    expect(deact).toBe(nt);
+    expect(deact).toBe('b');
+  });
+
+  test('wrap: same target + round bump', () => {
+    // order a,b,c. c current. nextTurn → wrap → a (r+1). deact c → wrap → a (r+1).
+    const e = enc([p('a',10),p('b',5),p('c',3)], { isStarted:true,
+      turnOrderIds:['a','b','c'], currentTurnParticipantId:'c', round:2 });
+    const nt = nextTurn(e).patch;
+    const deact = toggleParticipantActive(e, 'c').patch;
+    expect(deact.currentTurnParticipantId).toBe(nt.currentTurnParticipantId);
+    expect(deact.currentTurnParticipantId).toBe('a');
+    expect(deact.round).toBe(nt.round);
+    expect(deact.round).toBe(3);
+  });
+});