fix(#1051): force-exit + per-chunk timeout for the windows full-test lane; close leaked test handles (#1054)

The `full test (windows-latest, 22)` job intermittently got CANCELLED at its
20m wall-clock cap with no failed test step — a false-negative gate (recurrence
of #869). Root cause: a unit test leaves an open event-loop handle, so the
chunk's `node --test` child hangs ~150s on Windows after its last test prints;
two such stalls push the already-~13m job past 20m.

Fix (defense in depth):
- run-tests.cjs: pass --test-force-exit (Node >=22; engines requires >=22.0.0)
  so the runner exits once all tests finish regardless of lingering handles —
  the durable backstop. Account for the flag in the argv-length ceiling.
- run-tests.cjs: add a per-chunk execFileSync timeout (default 600000ms, env
  RUN_TESTS_CHUNK_TIMEOUT_MS) that fails loudly with a diagnostic naming the
  chunk's files, so a hung chunk can never silently eat the job budget.
- perf-316 test: terminate both Worker threads on all paths (afterEach +
  finally) so they cannot outlive the test.
- locking-bugs test: kill spawned children in a finally that wraps the whole
  spawn -> waitFor -> barrier-release -> Promise.all sequence, so a barrier
  timeout no longer leaks live child processes.
- Refresh the stale synckit comment (synckit/SDK bridge was removed).

Regression tests in run-tests-harness: a hung chunk hits the per-chunk timeout
and fails with a clear message; force-exit lets a chunk with a leaked handle
exit cleanly.

Closes #1051

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

tests/perf-316-state-lock-buffer-alloc.test.cjs

@@ -139,6 +139,7 @@ describe('perf #316: acquireStateLock hoists sleep buffer — exactly one SAB pe
   let tmpDir;
   let statePath;
   let lockPath;
+  let holderWorker;
 
   beforeEach(() => {
     tmpDir = makeTempDir();
@@ -147,7 +148,9 @@ describe('perf #316: acquireStateLock hoists sleep buffer — exactly one SAB pe
     fs.writeFileSync(statePath, MINIMAL_STATE_MD, 'utf-8');
   });
 
-  afterEach(() => {
+  afterEach(async () => {
+    await holderWorker?.terminate();
+    holderWorker = null;
     try { fs.unlinkSync(lockPath); } catch { /* already gone */ }
     removeTempDir(tmpDir);
   });
@@ -162,7 +165,6 @@ describe('perf #316: acquireStateLock hoists sleep buffer — exactly one SAB pe
       // intervals ~1000ms ≈ hold duration). The lockAttempts assertion below
       // proves the retry path was exercised end-to-end.
       const holdMs = 1000;
-      let holderWorker;
       let resolveLockWritten;
       const lockWritten = new Promise((resolve) => { resolveLockWritten = resolve; });
       const holderDone = new Promise((resolve, reject) => {
@@ -210,22 +212,28 @@ describe('perf #316: acquireStateLock hoists sleep buffer — exactly one SAB pe
       assert.ok(fs.existsSync(lockPath), 'Worker A must have written the lock file');
 
       // ── Worker B: call writeStateMd, measure SAB allocations ───────────────
-      const writeResult = await new Promise((resolve, reject) => {
-        const writer = new Worker(WRITER_WORKER_CODE, {
-          eval: true,
-          workerData: {
-            stateCjsPath: STATE_CJS_PATH,
-            statePath,
-            content: MINIMAL_STATE_MD,
-            tmpDir,
-          },
+      let writerWorker;
+      let writeResult;
+      try {
+        writeResult = await new Promise((resolve, reject) => {
+          writerWorker = new Worker(WRITER_WORKER_CODE, {
+            eval: true,
+            workerData: {
+              stateCjsPath: STATE_CJS_PATH,
+              statePath,
+              content: MINIMAL_STATE_MD,
+              tmpDir,
+            },
+          });
+          writerWorker.on('message', resolve);
+          writerWorker.on('error', reject);
+          writerWorker.on('exit', (code) => {
+            if (code !== 0) reject(new Error('Writer worker exit code: ' + code));
+          });
         });
-        writer.on('message', resolve);
-        writer.on('error', reject);
-        writer.on('exit', (code) => {
-          if (code !== 0) reject(new Error('Writer worker exit code: ' + code));
-        });
-      });
+      } finally {
+        await writerWorker?.terminate();
+      }
 
       // Wait for Worker A to finish releasing
       await holderDone;