core: staged-bootstrap kernel tier; move second/peek/subvec/mapv/update to Clojure

First fractal turn of the multi-stage bootstrap (jolt-tzo). The Clojure part of
clojure.core is now loaded in ordered tiers under jolt-core/clojure/core/. The
kernel tier (00-kernel: second/peek/subvec/mapv/update) holds the structural fns
the self-hosted compiler itself uses; in compile mode it is bootstrap-compiled
into clojure.core BEFORE the analyzer is built, so the analyzer binds those names
to the Clojure definitions instead of a not-yet-defined forward ref. That removes
the circularity that previously forced these to stay in Janet — the five core-*
primitives and their init-core! entries are gone.

Mechanism: backend/bootstrap-load-source (generalized from compile-load) builds a
source string into a target ns via the bootstrap; rebuild-compiler! recompiles
the self-hosted compiler against the current core (the rail for future turns,
exercised by the new fixpoint test). api/load-core-overlay! walks the ordered
tiers, bootstrap-loading kernel tiers and self-hosting the rest.

Also fixes a latent evaluator bug surfaced by the move: a fn rebinds current-ns
to its defining ns while it runs and restores on normal return, but a fn that
THREW unwound past its own restore, leaking the ns. try now restores the
try-entry ns on the catch/finally path, so referred-symbol resolution survives a
caught error (this was breaking is/testing in the suite harness after any thrown
assertion). Net battery +3 (3913 -> 3916); conformance 218/218 in all three
modes; binary builds and runs the embedded tiers.

jolt-core/clojure/core/00-kernel.clj

@@ -0,0 +1,46 @@
+;; clojure.core — kernel tier (stage just above the Janet seed).
+;;
+;; These are the structural fns the self-hosted compiler itself uses
+;; (jolt.analyzer): second/peek/subvec/mapv/update. Because the compiler must be
+;; able to compile the *rest* of clojure.core, anything it calls has to exist
+;; before it is built. So this tier is loaded FIRST and, in compile mode, is
+;; bootstrap-compiled directly into clojure.core (not routed through the
+;; self-hosted pipeline, which would need these to already exist — the
+;; circularity that previously forced `second` to stay in Janet). With this tier
+;; in place the analyzer is built against the Clojure definitions and the Janet
+;; primitives are gone.
+;;
+;; Constraint: depend only on core-renames primitives (first/next/nth/count/conj/
+;; vec/map/apply/assoc/get/…, all hardwired to the Janet seed) and on each other.
+
+(defn second [coll] (first (next coll)))
+
+(defn peek [coll]
+  (cond
+    (nil? coll) nil
+    ;; vectors (incl. jolt's eager seq results): last element; lists/seqs: first.
+    (vector? coll) (if (zero? (count coll)) nil (nth coll (dec (count coll))))
+    (seq? coll) (first coll)
+    :else (throw (str "peek not supported on: " coll))))
+
+(defn subvec
+  ([v start] (subvec v start (count v)))
+  ([v start end]
+   (when (not (vector? v)) (throw (str "subvec requires a vector")))
+   ;; Clojure coerces indices with (int ...): NaN -> 0, floats/ratios truncate
+   ;; toward zero ((quot x 1)); non-numbers throw. Only then range-check.
+   (let [coerce (fn [x]
+                  (cond
+                    (not (number? x)) (throw (str "subvec index must be a number"))
+                    (not= x x) 0
+                    :else (quot x 1)))
+         s (coerce start)
+         e (coerce end)]
+     (when (or (< s 0) (< e s) (< (count v) e))
+       (throw (str "subvec index out of range: " s " " e)))
+     (loop [i s acc []]
+       (if (< i e) (recur (inc i) (conj acc (nth v i))) acc)))))
+
+(defn mapv [f & colls] (vec (apply map f colls)))
+
+(defn update [m k f & args] (assoc m k (apply f (get m k) args)))