refactor: 1-list turn order model (turnOrderIds === participants.map(id))

Single source of truth. No re-sort after startEncounter. Drag overrides
initiative (cross-init drag allowed, DM choice). Display === rotation by
construction — same array.

shared/turn.js:
- syncTurnOrder(participants) helper: turnOrderIds = participants.map(id)
- startEncounter: sort ALL participants by init (active+inactive), inactive
  stay in slot, nextTurn skips them. currentTurn = first active.
- addParticipant: splice into participants[] by init pos, sync turnOrderIds.
  computeTurnOrderAfterAddition returns insertAt (caller splices + syncs).
- removeParticipant: filter participants[], sync turnOrderIds, advance
  current if removed==current.
- toggleParticipantActive: stay in slot (flip isActive only), sync. Advance
  current only if deact hits current.
- reorderParticipants: cross-init drag allowed (remove same-init restriction).
  Splice participants[], sync turnOrderIds. Fixes BUG-6.
- computeTurnOrderAfterRemoval: only handles current-advance now (list sync
  at call site).

Tests updated to 1-list contract:
- turn.invariant.test.js: 10 tests, turnOrderIds===participants.map(id)
  always, cross-init drag, inactive-in-slot, rotation follows list.
- turn.characterization/reorder/round-rotation/undo/remove: updated
  expectations (inactive-in-slot, cross-init drag, turnOrderIds sync on
  reorder, insertAt return).

Results: shared 90 green. 500-round replay CLEAN (0 skips, 0 doubles,
0 order shifts). BUG-6 (reorder divergence) fixed structurally.

FE App.js still has duplicate turn funcs + sortParticipantsByInitiative
display render (step 4: delete dups, render participants[] directly).

shared/tests/turn.round-rotation.test.js

@@ -112,17 +112,17 @@ describe('round rotation with mid-round state changes', () => {
     // start with 'c' inactive
     e.participants = e.participants.map(p => p.id === 'c' ? { ...p, isActive: false } : p);
     e = { ...e, ...startEncounter(e).patch };
-    const startOrder = e.turnOrderIds.slice(); // should be a,b,d (c excluded)
-
-    expect(startOrder).not.toContain('c');
+    // 1-list: c stays in slot (inactive), skipped by nextTurn
+    expect(e.turnOrderIds).toEqual(['a', 'b', 'c', 'd']);
+    expect(e.currentTurnParticipantId).toBe('a'); // c inactive, a first
 
     // advance one turn, then reactivate c
-    e = { ...e, ...nextTurn(e).patch };
+    e = { ...e, ...nextTurn(e).patch }; // b
     e = { ...e, ...toggleParticipantActive(e, 'c').patch };
 
     // continue rotation - c should now be reachable
-    const visited = [startOrder[0], e.currentTurnParticipantId];
-    for (let i = 0; i < startOrder.length; i++) {
+    const visited = [e.currentTurnParticipantId];
+    for (let i = 0; i < e.turnOrderIds.length; i++) {
       e = { ...e, ...nextTurn(e).patch };
       visited.push(e.currentTurnParticipantId);
     }