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.

src/jolt/clojure/string.clj

@@ -1,157 +0,0 @@
-; Jolt Standard Library: clojure.string
-; String manipulation functions using Jolt core string interop.
-
-(defn blank?
-  [s]
-  (if (nil? s) true
-    (= 0 (count (str-trim s)))))
-
-(defn capitalize
-  
-  [s]
-  (if (< 1 (count s))
-    (str (str-upper (subs s 0 1))
-         (str-lower (subs s 1)))
-    (str-upper s)))
-
-(defn lower-case
-  
-  [s]
-  (str-lower s))
-
-(defn upper-case
-  
-  [s]
-  (str-upper s))
-
-(defn includes?
-  
-  [s substr]
-  (not (nil? (str-find substr s))))
-
-(defn join
-  
-  ([coll] (str-join coll))
-  ([separator coll] (str-join coll separator)))
-
-(defn replace
-  [s match replacement]
-  (str-replace-all match replacement s))
-
-(defn replace-first
-  [s match replacement]
-  (str-replace match replacement s))
-
-(defn reverse
-  [s]
-  (str-reverse-b s))
-
-(defn str-reverse
-  [s]
-  (str-reverse-b s))
-
-(defn split
-  ([s re] (split s re 0))
-  ([s re limit]
-   ;; Java Pattern.split semantics: limit > 0 caps the parts (trailing empties
-   ;; kept); limit < 0 splits fully and keeps trailing empties; limit 0 (the
-   ;; default) splits fully then drops trailing empty strings — but a no-match
-   ;; result ([input], the only 1-element case) is returned as-is.
-   (let [parts (vec (str-split re s (if (pos? limit) limit nil)))]
-     (if (and (zero? limit) (> (count parts) 1))
-       (loop [v parts] (if (and (seq v) (= "" (peek v))) (recur (pop v)) v))
-       parts))))
-
-(defn split-lines
-  "Split s on \\n or \\r\\n, returning a vector of lines."
-  [s]
-  (vec (str-split #"\r?\n" s)))
-
-(defn starts-with?
-  
-  [s substr]
-  (let [slen (count s) slen2 (count substr)]
-    (and (>= slen slen2)
-         (= (subs s 0 slen2) substr))))
-
-(defn ends-with?
-  
-  [s substr]
-  (let [slen (count s) slen2 (count substr)]
-    (and (>= slen slen2)
-         (= (subs s (- slen slen2)) substr))))
-
-(defn trim
-  
-  [s]
-  (str-trim s))
-
-(defn triml
-  
-  [s]
-  (str-triml s))
-
-(defn trimr
-  
-  [s]
-  (str-trimr s))
-
-(defn trim-newline
-  
-  [s]
-  (var result s)
-  (while (or (= (subs result (dec (count result))) "\n")
-             (= (subs result (dec (count result))) "\r"))
-    (set result (subs result 0 (dec (count result)))))
-  result)
-
-(defn escape
-  
-  [s cmap]
-  (apply str
-    (map (fn [ch]
-           (if-let [rep (cmap ch)] rep (str ch)))
-         s)))
-
-(defn index-of
-  "0-based index of the first occurrence of value in s, or nil."
-  ([s value]
-   (str-find value s))
-  ([s value from]
-   (let [idx (str-find value (subs s from))]
-     (when idx (+ from idx)))))
-
-(defn last-index-of
-  
-  ([s value]
-   (let [r (str-reverse-b s) sval (str-reverse-b value)
-         idx (str-find sval r)]
-     (when idx (- (count s) (+ idx (count value))))))
-  ([s value from]
-   (let [sub (subs s 0 from) r (str-reverse-b sub) sval (str-reverse-b value)
-         idx (str-find sval r)]
-     (when idx (- from (+ idx (count value)))))))
-
-(defn re-quote-replacement
-  "Escape special characters (backslash and dollar) in a regex replacement
-  string so it is used literally rather than interpreted."
-  [replacement]
-  (apply str
-    (map (fn [ch]
-           (let [c (str ch)]
-             (if (or (= c "\\") (= c "$")) (str "\\" c) c)))
-         (seq replacement))))
-
-;; Ported from clojure.string/trim-newline (CharSequence interop replaced with
-;; portable count/subs). Removes all trailing \n or \r characters.
-(defn trim-newline
-  "Removes all trailing newline \\n or return \\r characters from
-  string.  Similar to Perl's chomp."
-  [s]
-  (loop [index (count s)]
-    (if (zero? index)
-      ""
-      (let [c (subs s (dec index) index)]
-        (if (or (= c "\n") (= c "\r"))
-          (recur (dec index))
-          (subs s 0 index))))))