Clean up codebase: rename stdlib layer, strip porting residue, fix tooling

Rename src/jolt -> stdlib (the runtime-loaded layer; jolt-core stays the
seed-baked layer) and update the loader / emit-image / doc paths. Drop dead
code: the spike/ experiments, the duplicate clojuredocs-export.edn (json moves
to tools/), the Janet-era jolt.http binding, and the orphaned
persistent_vector.clj whose ns/path didn't even match.

Strip porting residue from comments and docstrings across host/chez, jolt-core,
stdlib, tests, and docs: internal issue ids, "Phase N" markers, and the "vs
Janet" historical exposition, leaving present-tense descriptions and the real
JVM-Clojure semantic contrasts. Same pass over the corpus suite labels. The seed
is unchanged (docstrings/comments aren't emitted), so the self-host fixpoint and
corpus are untouched.

Port tools/spec_coverage.py off the dead janet probe to bin/joltc and regenerate
coverage.md; drop the dead :host/janet rule from certify.clj and regenerate the
conformance profile. Add docs/host-interop.md (the JVM shims and how to register
your own host class from a library) and a writing-style note in CLAUDE.md.

Stabilize the four racy concurrency corpus cases (future-cancel and agent
send/send-off): give the future a sleeping body and the agent a slow action, so
cancel reliably catches an in-flight future and deref reliably reads the
pre-update snapshot. They certify deterministically now, so drop their :flaky
allowlist entries and the orphaned legend.

host/chez/concurrency.ss

@@ -1,13 +1,12 @@
-;; concurrency.ss (jolt-byjr) — real OS-thread futures + promises for the Chez host.
+;; concurrency.ss — real OS-thread futures + promises for the Chez host.
 ;;
-;; SHARED-HEAP semantics (JVM Clojure), NOT Janet's isolated-heap snapshot: a
-;; future body runs on a native thread (fork-thread) over the SAME heap, so a
-;; captured atom is shared and the body's mutations are visible to the parent —
-;; matching `clojure.core` on the JVM. deref blocks on a mutex+condition latch.
+;; SHARED-HEAP semantics, like JVM Clojure: a future body runs on a native thread
+;; (fork-thread) over the SAME heap, so a captured atom is shared and the body's
+;; mutations are visible to the parent. deref blocks on a mutex+condition latch.
 ;;
 ;; future / future-call / future-cancel / future? / future-done? / future-cancelled?
 ;; promise / deliver, and the deref extension for both, are bound here (some
-;; re-asserted in post-prelude.ss over the overlay's Janet-shaped versions).
+;; re-asserted in post-prelude.ss over the overlay's versions).
 ;;
 ;; pmap / pcalls / pvalues live in the clojure.core overlay (40-lazy) expressed
 ;; over `future`, so they light up for free once future-call exists.
@@ -105,8 +104,8 @@
   (and (jolt-future? x) (jolt-future-cancelled? x)))
 
 ;; --- promises ---------------------------------------------------------------
-;; A blocking promise (JVM), not Janet's non-blocking atom shim: deref parks until
-;; deliver, then caches the value. deliver wins once; later delivers return nil.
+;; A blocking promise (like the JVM): deref parks until deliver, then caches the
+;; value. deliver wins once; later delivers return nil.
 (define-record-type jolt-promise
   (fields (mutable delivered?) (mutable value) mu cv)
   (nongenerative jolt-promise-v1))
@@ -144,8 +143,8 @@
     (if got (jolt-promise-value p) timeout-val)))
 
 ;; --- agents (async, per-agent serialized dispatch) --------------------------
-;; JVM semantics, not Janet's synchronous shim: send/send-off enqueue an action
-;; and a single worker thread applies them to the state IN ORDER; deref reads the
+;; JVM semantics: send/send-off enqueue an action and a single worker thread
+;; applies them to the state IN ORDER; deref reads the
 ;; (possibly not-yet-updated) state without blocking; await blocks until the queue
 ;; drains. An action error is captured (agent-error) and stops the queue.
 (define-record-type jolt-agent
@@ -246,8 +245,8 @@
       ((jolt-delay? x) (jolt-delay-force x))
       (else (apply %pre-conc-deref x opts)))))
 
-;; realized? for a Chez future/promise/delay (the overlay reads Janet map keys).
-;; Wrapped over the overlay version in post-prelude.ss.
+;; realized? for a future/promise/delay. Wrapped over the overlay version in
+;; post-prelude.ss.
 (define (jolt-conc-realized? x)
   (cond ((jolt-future? x) (jolt-future-done? x))
         ((jolt-promise? x) (jolt-promise-delivered? x))
@@ -273,7 +272,7 @@
 (def-var! "clojure.core" "delay?" jolt-delay?)
 (def-var! "clojure.core" "deref" jolt-deref)
 
-;; --- cooperative thread interrupt (jolt-amzy) -------------------------------
+;; --- cooperative thread interrupt -------------------------------------------
 ;; Chez has no force-kill, but its engine timer (set-timer + timer-interrupt-
 ;; handler, thread-local) is polled at procedure-call / loop back-edges — so a
 ;; running computation, even a tight Scheme loop, can be aborted from another