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.

README.md

@@ -48,11 +48,16 @@ $ bin/joltc -e '(/ 1 2)'
 ## Architecture
 
 A small Chez runtime (`host/chez/*.ss`: value model, persistent collections, seqs,
-vars/namespaces, host interop) hosts a portable Clojure overlay (`jolt-core/`): the
-reader/analyzer/IR/backend (`jolt-core/jolt/`) and `clojure.core` in
-dependency-ordered tiers (`jolt-core/clojure/core/NN-*.clj`). The stdlib namespaces
-(`clojure.string`/`set`/`walk`/`edn`/`pprint`/…) are portable Clojure under
-`src/jolt/clojure/`.
+vars/namespaces, host interop) hosts a portable Clojure overlay split across two
+source roots by *when* they load:
+
+- **`jolt-core/`** is baked into the seed — the compiler (`jolt-core/jolt/`:
+  reader/analyzer/IR/backend, plus `jolt.main`/`jolt.deps`) and `clojure.core` in
+  dependency-ordered tiers (`jolt-core/clojure/core/NN-*.clj`). Changing anything
+  here means re-minting the seed.
+- **`stdlib/`** loads lazily at runtime off the source roots — the rest of the
+  standard library (`clojure.string`/`set`/`walk`/`edn`/`pprint`/…) plus the
+  `jolt.ffi` host library. Editing these needs no re-mint.
 
 `bin/joltc` loads the checked-in seed and the spine, then compiles and evaluates on
 Chez (read → analyze → IR → emit → eval). `host/chez/bootstrap.ss` rebuilds that
@@ -63,9 +68,11 @@ reproduces the checked-in seed byte-for-byte).
 
 Jolt targets Clojure semantics but runs on Chez, not the JVM.
 
-- **Host platform.** No JVM and no Java interop — `import`, `gen-class`, `proxy` of
-  Java classes, and `java.*` are unavailable. A class token resolves to a name; a
-  small set of host classes is recognized for `instance?`.
+- **Host platform.** No JVM, no reflection, no `gen-class`/`proxy` of Java
+  classes. Interop syntax (`Class.`, `Class/static`, `.method`) works against a
+  shimmed subset of the `java.*` standard library, and a class token resolves to
+  a name. See [docs/host-interop.md](docs/host-interop.md) for what's covered and
+  how to register your own host classes from a library.
 - **Numbers.** The full Scheme numeric tower, matching the JVM: exact integers and
   bignums, exact ratios (`(/ 1 2)` ⇒ `1/2`), and flonum doubles. `=` is
   category-aware (`(= 3 3.0)` ⇒ `false`); `==` is value-equality (`(== 3 3.0)` ⇒