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.

stdlib/clojure/sci/host_stubs.clj

@@ -0,0 +1,49 @@
+;; Forward-declaration stubs for SCI's host-layer modules.
+;;
+;; sci.impl.{parser,read,load,macroexpand,resolve,proxy,reify} implement SCI's
+;; reader, loader, macroexpander and JVM proxy/reify support. On the JVM those
+;; lean on tools.reader, java.io and reflection; Jolt has its own native
+;; reader/loader, so rather than load SCI's host implementation we provide just
+;; the var names that sci.impl.namespaces references when it builds the
+;; clojure.core binding map. The map is built at load time but these are only
+;; *called* through SCI's own runtime, which Jolt replaces — so no-op
+;; placeholders are sufficient. (They must be non-nil so `:refer` re-interns
+;; them: interning a nil-valued var drops the binding.)
+
+(ns sci.impl.parser)
+(defn parse-next [& _] nil)
+(def data-readers {})
+(defn default-data-reader-fn [& _] nil)
+(defn read-eval [& _] nil)
+(defn reader-resolver [& _] nil)
+(defn suppress-read [& _] nil)
+
+(ns sci.impl.read)
+(defn read [& _] nil)
+(defn read-string [& _] nil)
+(defn source-logging-reader [& _] nil)
+
+(ns sci.impl.load)
+(defn load-string [& _] nil)
+(defn load-reader [& _] nil)
+(defn add-loaded-lib [& _] nil)
+(defn eval-refer [& _] nil)
+(defn eval-refer-global [& _] nil)
+(defn eval-require [& _] nil)
+(defn eval-require-global [& _] nil)
+(defn eval-use [& _] nil)
+
+(ns sci.impl.macroexpand)
+(defn macroexpand [& _] nil)
+(defn macroexpand-1 [& _] nil)
+
+(ns sci.impl.resolve)
+(defn resolve-symbol [& _] nil)
+
+(ns sci.impl.proxy)
+(defn proxy [& _] nil)
+(defn proxy* [& _] nil)
+
+(ns sci.impl.reify)
+(defn reify [& _] nil)
+(defn reify* [& _] nil)