jspi cleanup: remove the asyncify-era residue — dead code, conditionals, pipeline scaffolding, stale prose

The runtime is JSPI-only; this removes everything that still pretended
otherwise. Three exhaustive sweeps (C++/JS+build+CI/tests+docs) drove
the inventory; every deletion verified by grep closure + full gates.

Broken-right-now fixes:
- deploy-staging.yml passed the retired opt_level input — the workflow
  could not even start. Removed.
- env.sh carried dead exports with a live -sASYNCIFY=1 inside
  (WASM_LDFLAGS/PTHREAD_LDFLAGS, zero consumers). Removed; the
  WASM_LEGACY_EXCEPTIONS rationale rewritten to the real reason.
- docker/build.sh exported PCBJAM_ASYNC_BACKEND (read nowhere). Gone.

Dead weight removed:
- binaryen submodule (nothing builds or invokes it), wasm-opt-bench
  workflow + scripts/bench/, get-wasm-opt.sh, diagnostics.js (242 lines
  of Asyncify-API-only code), the KICAD_PIPELINE background-postprocess
  scaffolding (existed to parallelize the deleted wasm-opt phase; the
  postprocess is a seconds-long node script and now runs inline),
  build-monitor's dead asyncify rows, sched-context orphan build
  output, dead .gitignore entries, the .jspi-assets spike dir (the two
  wf-result research JSONs moved to docs/features/async/migration-evidence/).
- bindings: fiber_park.h + its 12 embind registrations (broken-if-
  called under JSPI), the kicadOpenFileStart/OPEN_JOB starter route,
  main_stack_runner.h + 5 includes, the always-null context-sleep weak
  hook in nanosleep_yield.c.
- shim: the backend field (installed-flag idempotency instead),
  noteContextWait (dead both sides), the __wxAsyncifyDump alias (+ the
  WasmTool fallback and string-dump normalize branch).
- web: the emscripten-6-ignored mainScriptUrlOrBlob option in boot.ts
  (gerber-demo keeps it: it loads the deployed CDN release, which
  predates emscripten 6 — noted inline).

Conditionals: all 'backend === jspi' checks reduced to scheduler-
presence checks; races_quiescent re-keyed from Asyncify.state (vacuous)
to real backlog quiescence (resumeReady/mutatorQueue — NOT _windowLive,
which is the probing activation's own window by definition).

Renames (identifiers only, no file renames): ASYNC_LINK_FLAGS→
JSPI_LINK_FLAGS and Makefile ASYNC_LDFLAGS→JSPI_LDFLAGS,
kicadCollabFiberBusy→kicadCollabBusy (embind + web + tests),
collab_common.h fiber*→apply*/coroutine naming, asyncifySignatures→
wasmTrapSignatures (lists byte-identical).

Tests: the two remaining vacuous [wx-asyncify]/fiber-resume-refused
asserts re-keyed to live JSPI beacons; eeschema-load's failure message
no longer sends the developer to a deleted script; wait-beacons' dead
families/parser deleted; lane-0 legacy-glue guards removed (lane 0 is
unconstructible); the embind test.fail re-gated with the JSPI reason
(plain embind invokers cannot suspend — verified still failing);
lint-determinism now scans tests/jspi (166 files clean);
eeschema-collab local-move gated to chromium (~50% flaky on FF even
solo; pcbnew twin covers both engines).

Docs: DEBUG.md rewritten as the JSPI debugging guide; build.md
describes the single-phase build; docs/features/async/README.md
banner-marked historical and repointed at the NEW
23-jspi-runtime.md (current architecture: export census, turnstile,
libcontext ownership + refusal contract, embind call shapes, the
em-pthread service-wrapper trick, exception policy, known gaps).

Gates on the cleaned tree: test:e2e 725 passed / 0 failed (after the
quiescence-probe fix; the 3 other reds were verified contention flakes
solo-green or the documented FF gate), web 76/0, jspi 18/18 both
engines, vitest 295/295 + 17/17, all lints green, live-app census
clean.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016X9eh1s5sTx1o9Em9KBuwR

wasm/shims/nanosleep_yield.c

@@ -1,7 +1,7 @@
 /*
- * nanosleep_yield.c — make a MAIN-THREAD nanosleep() YIELD to the JS event loop via
- * Asyncify instead of busy-spinning, so on-demand pthread-Worker creation can complete
- * WITHOUT editing KiCad.
+ * nanosleep_yield.c — make a MAIN-THREAD nanosleep() YIELD to the JS event loop
+ * (a JSPI suspension) instead of busy-spinning, so on-demand pthread-Worker
+ * creation can complete WITHOUT editing KiCad.
  *
  * THE PROBLEM (the "non-warm thread" deadlock): once KiCad's thread pool has consumed all
  * the pre-warmed Workers (-sPTHREAD_POOL_SIZE), a later raw std::thread (the raytracer)
@@ -10,11 +10,11 @@
  * -> nanosleep -> emscripten_thread_sleep, which busy-spins and NEVER returns to the JS
  * event loop, so the new Worker never starts -> deadlock.
  *
- * THE FIX: the only main-thread primitive that returns to the event loop is an Asyncify
- * unwind (emscripten_sleep). This provides a nanosleep that, ON THE MAIN THREAD, yields via
- * an EM_ASYNC_JS await (= emscripten_sleep semantics; __asyncjs__* is already in the
- * post-link asyncify-imports). The unmodified sleep_for busy-wait then pumps the loop, the
- * Worker handshake completes, and on-demand creation works with no KiCad edit.
+ * THE FIX: the only main-thread primitive that returns to the event loop is a suspension.
+ * This provides a nanosleep that, ON THE MAIN THREAD, yields via an EM_ASYNC_JS await
+ * (= emscripten_sleep semantics under JSPI). The unmodified sleep_for busy-wait then pumps
+ * the loop, the Worker handshake completes, and on-demand creation works with no KiCad
+ * edit.
  *
  * MECHANISM: a STRONG definition of nanosleep here SHADOWS musl's archive member — the
  * linker only pulls musl's nanosleep.o if the symbol is left undefined, and ours defines it.
@@ -38,42 +38,20 @@
 #include <emscripten/threading.h>
 #include <time.h>
 
-/* EM_ASYNC_JS integrates with Asyncify automatically (binaryen instruments every caller). */
+/* EM_ASYNC_JS is a suspending import: JSPI suspends every activation that awaits it. */
 EM_ASYNC_JS( void, __wasm_main_thread_yield_ms, ( double ms ), {
-    /* JSPI: route through the scheduler's turnstile when it exists - a raw
-       await's engine-level resume bypasses the shim's SP discipline and
-       leaves its window marked live (the pump then refuses every later
-       resume). Asyncify builds (no jspi scheduler) keep the raw await. */
+    /* Route through the scheduler's turnstile when it exists - a raw await's
+       engine-level resume bypasses the shim's SP discipline and leaves its
+       window marked live (the pump then refuses every later resume). The
+       scheduler-free harness builds keep the raw await. */
     var S = globalThis.__wxScheduler;
-    if( S && S.backend === 'jspi' ) {
+    if( S ) {
         await S.sleepYield( ms );
         return;
     }
     await new Promise( function( resolve ) { setTimeout( resolve, ms ); } );
 } );
 
-/*
- * Scheduler-aware sleep (context_sleep.cpp, docs/features/async/22 Phase B):
- * when this frame stands on a scheduler context that owns the stack, the wait
- * PARKS THAT CONTEXT instead of suspending the stack in place. Returns 0 when
- * no context owns the stack, and then the Asyncify yield below is still right.
- *
- * This is what makes TOOL_MANAGER::RunSynchronousAction's spin loop safe under
- * Phase D: an in-place park inside a tool body leaves a capture in flight for a
- * star transfer to land on (doRewind -> "index out of bounds").
- *
- * extern "C" + WEAK, both load-bearing: some app builds compile this file as
- * C++ (em++ keys language off the DRIVER, not the .c extension — a bare extern
- * here mangles and the app aborts at "missing function" on first sleep), and
- * the standalone wx test apps do not link context_sleep.cpp at all. A weak
- * null resolves to "no context lane here — always yield in place", which is
- * exactly the pre-context behaviour those apps pin.
- */
-#ifdef __cplusplus
-extern "C"
-#endif
-int pcbjam_context_sleep_ms( double ms ) __attribute__(( weak ));
-
 int nanosleep( const struct timespec* req, struct timespec* rem )
 {
     if( req )
@@ -82,10 +60,7 @@ int nanosleep( const struct timespec* req, struct timespec* rem )
         if( ms > 0.0 )
         {
             if( emscripten_is_main_runtime_thread() )
-            {
-                if( !pcbjam_context_sleep_ms || !pcbjam_context_sleep_ms( ms ) )
-                    __wasm_main_thread_yield_ms( ms ); /* yield -> event loop runs -> Worker boots */
-            }
+                __wasm_main_thread_yield_ms( ms ); /* yield -> event loop runs -> Worker boots */
             else
                 emscripten_thread_sleep( ms );     /* worker: real blocking sleep */
         }