refactor(sync): extract submitLocalBatch as the single local intake

[winlp4ever]

What

First, behavior-neutral step of S7 (headless sync-correct emit). Extracts the single local-batch intake that the headless producer (S7b) will call, without changing any current behavior.

Why

Local batches reach the sync coordinator two ways today:

• store-commit path — attachSync.sendBatch registers the batch in the pending rebase set and schedules a pump (correct);
• direct oplog write — getBoardPersistenceRef().record(...) in the deep-cascade delete (subtree.ts) lands in the oplog but never joins pending, never triggers a pump, and never gets a serverSeq on ack. On a synced board that batch ships opportunistically and is never rebased against concurrent remote ops — the "bypasses the outbox -> desyncs" hazard.

S7b needs one correct place for an off-scene / cross-layer producer to enter. This PR creates it.

How

• board-sync.ts: extract submitLocalBatch(batch) = register in the pending rebase set + schedulePump(). attachSync.sendBatch now routes through it (identical behavior). Exposed on BoardSyncHandle.
• board-sync-ref.ts (new): module singleton mirroring board-persistence-ref, so code outside the harness can reach submitLocalBatch. null on a purely local board (no relay) — callers fall back to the persistence ref, which is sync-correct there.
• use-board-sync-v2.ts: publish the handle via setBoardSyncRef on mount, clear on detach (before handle.detach()).

No producer is rewired onto the headless path in this PR — the store path is untouched, and the subtree.ts bypass is left as-is (fixed in S7b, where the durable-only rebase handling and ack/serverSeq stamping land with their own tests).

Test plan

• New test: a batch that was never applied to the live store is recorded to the oplog and entered via handle.submitLocalBatch(...); it ships as one relay message and the peer converges — proving the exposed seam takes the outbox/rebase path, not a bypass.
• All 29 existing board-sync behaviors pass unchanged.
• npm run check-all passes.

Follow-ups (rest of S7)

• S7b — route subtree.ts (and the future headless BoardMutator) through submitLocalBatch into a durable-only rebase set (off-layer batches must be excluded from the in-scene undo/replay loop, since their inverse would re-add nodes into the wrong layer's store), with ack/serverSeq stamping.
• S7c — ADR-SYNC-001 update documenting "one intake, two producers, one seq authority" and the scene-vs-durable-only rebase split.

[winlp4ever]

Review response (code-review high)

Addressed the seam-contract findings in a7fb33e:

• Rebase-injection (finding feat(*): first commit #1): submitLocalBatch now takes scene (default true). Store commits stay rebase-tracked; a headless / off-scene batch enters with scene: false — pumped but kept out of the rebase set, so applyRemote never replays its off-layer ops into the loaded scene.
• Weak test (finding feat(*): setup semantic versioning #2): the seam test now seeds an in-scene edit, submits a headless batch with scene: false, and drives a concurrent remote op afterward — asserting the off-scene node reaches the peer but is never injected into the submitter's store (before or after the rebase).
• Unused seam (finding ci(github): publish github releases from workflow #3): the subtree.ts migration stays in S7b (its own behavior change + tests), but the headless (scene: false) branch is now directly exercised by the test, so it is not dead code.

Bonus — this de-risks S7b. Since off-scene batches never enter pending, they never hit applyBatch, so the cross-layer inverse-safety concern (undoing a node.remove re-adding a node into the wrong layer) disappears entirely. S7b becomes: record + submitLocalBatch(batch, { scene: false }) — no durable-only rebase set needed.