core: compile macro expanders via staged bootstrap (Stage 2 Task 1)

Macros are now compiled, not interpreted, by steady state — matching
Clojure (macros are ordinary compiled fns the Java seed compiles for
clojure.core) and ClojureScript (macros compiled, invoked at compile
time). Neither reference keeps an interpreted-closure fallback.

The early macros (00-syntax) are defined while the self-hosted analyzer
is still being bootstrapped (it builds lazily after the overlay loads),
so macro-compile-hook returns nil and they get an interpreted closure.
The bootstrap compiler.janet can't substitute (it punts on syntax-quote,
which nearly every expander uses).

Fix = staged bootstrap, the same pattern as the compiler fixpoint:
defmacro stashes the expander source on the var (:macro-src) plus a
:macro-uses-env flag; once the overlay + analyzer are fully built,
backend/recompile-macros! (via ensure-macros-compiled! at the end of
load-core-overlay!) compiles each stashed expander through the now-live
analyzer and rebinds the var, marking :macro-compiled. Idempotent;
&env/&form macros keep the interpreted closure (the compiled fn* has no
such params). The interpreter is now a build-time crutch, gone by
steady state.

Rewrote if-not/if-let/if-some/assert from '& [else]' rest-destructuring
(which the analyzer punts on) to a plain rest param + (first rest), so
all 47 overlay macros compile. Analyzer rest-destructuring gap: jolt-f79.

47/47 overlay macros compiled, 0 interpreted; user macros compile
immediately post-init. Gate green: conformance 267x3, fallback-zero
31/5, bootstrap-fixpoint stage1==2==3, self-host, staged-bootstrap,
lazy-infinite 44/44, clojure-test-suite >=4034/67, sci-bootstrap,
features 78/78, all unit+spec, core-bench neutral.

jolt-core/clojure/core/30-macros.clj

@@ -12,25 +12,27 @@
 
 (defmacro comment [& body] nil)
 
-;; Single arglist (Jolt defmacro is single-arity); the optional else defaults nil
-;; via rest-destructuring.
-(defmacro if-not [test then & [else]]
-  `(if (not ~test) ~then ~else))
+;; Single arglist (Jolt defmacro is single-arity); the optional else is the head of
+;; a plain rest param — (first else) is the else form or nil. (A `& [else]`-style
+;; rest-destructure reads the same but the analyzer can't yet compile destructuring
+;; in a rest param, which would force this expander to stay interpreted — jolt-f79.)
+(defmacro if-not [test then & else]
+  `(if (not ~test) ~then ~(first else)))
 
 ;; Conditional binding macros: the name is bound ONLY in the taken branch (the
 ;; auto-gensym temp# tests the value; the else/empty branch sees the surrounding
 ;; scope). temp# is a single template-local gensym — referenced twice, same symbol.
-(defmacro if-let [bindings then & [else]]
+(defmacro if-let [bindings then & else]
   (let [form (bindings 0) tst (bindings 1)]
     `(let [temp# ~tst]
-       (if temp# (let [~form temp#] ~then) ~else))))
+       (if temp# (let [~form temp#] ~then) ~(first else)))))
 
 ;; when-let lives in 00-syntax (not here): 20-coll uses it, which loads before this tier.
 
-(defmacro if-some [bindings then & [else]]
+(defmacro if-some [bindings then & else]
   (let [form (bindings 0) tst (bindings 1)]
     `(let [temp# ~tst]
-       (if (some? temp#) (let [~form temp#] ~then) ~else))))
+       (if (some? temp#) (let [~form temp#] ~then) ~(first else)))))
 
 (defmacro when-some [bindings & body]
   (let [form (bindings 0) tst (bindings 1)]
@@ -91,8 +93,9 @@
                    (partition 2 clauses))]
     `(let [~g ~expr ~@(thread-binds g steps)] ~(if (empty? steps) g (last steps)))))
 
-(defmacro assert [x & [message]]
-  (let [msg (if message message (str "Assert failed: " (pr-str x)))]
+(defmacro assert [x & message]
+  (let [m (first message)
+        msg (if m m (str "Assert failed: " (pr-str x)))]
     `(when-not ~x (throw (ex-info ~msg {})))))
 
 (defmacro delay [& body]