Compiler research (#10)

adds self-hosted compiler is functionally:
 
- The default compile path is the portable pipeline using jolt.analyzer (Clojure) → host-neutral IR → backend.janet.
- The analyzer is itself Clojure, compiled by jolt for true self-hosting.
- bootstrap-fixpoint passes (stage1 == stage2 == stage3): rebuilding the compiler on its own output.
- clojure.core is now self-hosted in the overlay.
- Stateful forms (defmacro/ns/deftype/defmulti/require/in-ns) are interpreted by design.

test/spec/macros-spec.janet

@@ -25,3 +25,50 @@
    "(= (gensym) (gensym))"]
   ["gensym# in template" "true"
    "(do (defmacro m [] `(let [x# 1] x#)) (= 1 (m)))"])
+
+# Core macros ported from Janet to the Clojure overlay (jolt-1j0 phase 3,
+# jolt-core/clojure/core/30-macros.clj).
+(defspec "macros / core-overlay"
+  ["if-not true branch"  ":then"  "(if-not false :then :else)"]
+  ["if-not else branch"  ":else"  "(if-not true :then :else)"]
+  ["if-not no else"      "nil"    "(if-not true :then)"]
+  ["if-not no else hit"  ":then"  "(if-not false :then)"]
+  ["comment -> nil"      "nil"    "(comment a b c)"]
+  ["comment in do"       "42"     "(do (comment ignored) 42)"]
+  ["if-let then"         "6"      "(if-let [x 5] (inc x) :none)"]
+  ["if-let else"         ":none"  "(if-let [x nil] (inc x) :none)"]
+  ["if-let else scope"   "9"      "(let [x 9] (if-let [x nil] :t x))"]
+  ["if-some zero"        "1"      "(if-some [x 0] (inc x) :none)"]
+  ["if-some nil"         ":none"  "(if-some [x nil] x :none)"]
+  ["when-some multi"     "14"     "(when-some [x 7] (inc x) (* x 2))"]
+  ["when-some nil"       "nil"    "(when-some [x nil] x)"]
+  ["while loop"          "3"      "(let [a (atom 0)] (while (< @a 3) (swap! a inc)) @a)"]
+  ["dotimes sum"         "10"     "(let [a (atom 0)] (dotimes [i 5] (swap! a + i)) @a)"]
+  ["as-> threads"        "12"     "(as-> 5 x (+ x 1) (* x 2))"]
+  ["as-> no forms"       "5"      "(as-> 5 x)"]
+  ["some-> through"      "6"      "(some-> {:a {:b 5}} :a :b inc)"]
+  ["some-> short-circuit" "nil"   "(some-> {:a nil} :a :b)"]
+  ["some->> through"     "9"      "(some->> [1 2 3] (map inc) (reduce +))"]
+  ["some->> nil"         "nil"    "(some->> nil (map inc))"]
+  ["doto returns obj"    "[1 2]"  "(deref (doto (atom []) (swap! conj 1) (swap! conj 2)))"]
+  ["when-first"          "20"     "(when-first [x [10 20 30]] (* x 2))"]
+  ["when-first empty"    "nil"    "(when-first [x []] :body)"]
+  ["when-first nil coll" "nil"    "(when-first [x nil] :body)"]
+  ["when-first range"    "0"      "(when-first [x (range 5)] x)"]
+  ["cond->> threads"     "12"     "(cond->> 5 true (+ 1) false (* 100) true (* 2))"]
+  ["cond->> skip"        "10"     "(cond->> 10 false (+ 1))"]
+  ["assert pass"         ":ok"    "(do (assert (= 1 1)) :ok)"]
+  ["assert throws"       ":threw" "(try (assert (= 1 2)) (catch :default e :threw))"]
+  ["assert message"      "\"nope\"" "(try (assert false \"nope\") (catch :default e (ex-message e)))"]
+  ["delay value"         "42"     "(deref (delay 42))"]
+  ["delay forces once"   "1"      "(let [c (atom 0) d (delay (swap! c inc))] @d @d @c)"]
+  ["future deref"        "9"      "(deref (future (* 3 3)))"]
+  ["letfn simple"        "25"     "(letfn [(sq [x] (* x x))] (sq 5))"]
+  ["letfn mutual"        "true"   "(letfn [(ev? [n] (if (zero? n) true (od? (dec n)))) (od? [n] (if (zero? n) false (ev? (dec n))))] (ev? 8))"]
+  ["condp match"         ":two"   "(condp = 2 1 :one 2 :two 3 :three)"]
+  ["condp default"       ":else"  "(condp = 9 1 :one 2 :two :else)"]
+  ["condp :>> form"      "\"got 2\"" "(condp some [1 2 3] #{0 9} :>> (fn [x] (str \"got \" x)) #{2 6} :>> (fn [x] (str \"got \" x)))"]
+  ["condp no match"      ":threw" "(try (condp = 9 1 :one) (catch :default e :threw))"]
+  ["binding rebinds"     "99"     "(do (def ^:dynamic *bx* 10) (binding [*bx* 99] *bx*))"]
+  ["binding restores"    "10"     "(do (def ^:dynamic *by* 10) (binding [*by* 99] *by*) *by*)"]
+  ["binding seen by fn"  "7"      "(do (def ^:dynamic *bz* 0) (defn rdz [] *bz*) (binding [*bz* 7] (rdz)))"])