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)

stdlib/clojure/sci/io_stubs.clj

@@ -0,0 +1,36 @@
+; Minimal sci.impl.io stub for the Jolt bootstrap.
+; SCI's real io.cljc needs JVM/CLJS-only features (System/getenv, *print-meta*,
+; thread-local *out* binding). Jolt has native I/O, so we provide just the names
+; that sci.impl.namespaces references when building the clojure.core binding map,
+; backed by Jolt's native equivalents. (Only references symbols Jolt defines.)
+(ns sci.impl.io)
+
+(def out (atom nil))
+(def in (atom nil))
+(def err (atom nil))
+(def newline (fn newline [] (clojure.core/pr "\n") nil))
+(def flush (fn flush [] nil))
+(def pr clojure.core/pr)
+(def prn clojure.core/prn)
+(def print clojure.core/print)
+(def println clojure.core/println)
+(def pr-str clojure.core/pr-str)
+(def prn-str clojure.core/prn-str)
+(def print-str clojure.core/str)
+(def println-str clojure.core/println-str)
+(def printf (fn printf [fmt & args] (clojure.core/print (apply clojure.core/format fmt args)) nil))
+(def print-simple (fn print-simple [o w] (clojure.core/pr o) nil))
+(def read-line (fn read-line [] nil))
+(def with-out-str (fn with-out-str [& body] ""))
+(def with-in-str (fn with-in-str [s & body] nil))
+(def print-dup-var (atom false))
+(def print-meta (atom false))
+(def print-readably (atom true))
+(def print-length (atom nil))
+(def print-level (atom nil))
+(def print-namespace-maps (atom false))
+(def print-newline (atom true))
+(def flush-on-newline (atom true))
+(def print-fn (atom nil))
+(def print-err-fn (atom nil))
+(def file (atom nil))

stdlib/clojure/sci/lang_stubs.clj

@@ -0,0 +1,32 @@
+; Minimal SCI type stubs for Jolt bootstrap
+; Provides the deftype definitions that SCI's Clojure source references
+; before the full SCI runtime is loaded.
+
+; Protocol stubs for SCI's type system
+(defprotocol IBox (setVal [this v]) (getVal [this]))
+(defprotocol HasName (getName [this]))
+(defprotocol IVar (bindRoot [this v]) (getRawRoot [this]) (toSymbol [this])
+  (isMacro [this]) (setThreadBound [this v]) (unbind [this]) (hasRoot [this]))
+(defprotocol DynVar (dynamic? [this]))
+(defprotocol IReified (getInterfaces [this]) (getMethods [this])
+  (getProtocols [this]) (getFields [this]))
+
+; Unbound sentinel for vars
+(deftype SciUnbound [the-var])
+
+; Core SCI types — keep minimal for bootstrap
+(deftype Namespace [name mappings aliases imports])
+(deftype Var [root name meta macro dynamic ns])
+
+; Store stub (sci.ctx-store provides a global context atom)
+(def ctx-store (atom nil))
+
+; Macro helpers from sci.impl.macros
+(defn deftime [& body] nil)
+(defn usetime [& body] (eval (first body)))
+(defmacro ? [& args]
+  (if (contains? &env (quote &env))
+    (let [form (first args)]
+      (if (= :clj (first form))
+        (second form)
+        (if (= :cljs (first form)) nil)))))