Stage2 compile only (#12)

* 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.

* core: wrap macro expanders in fn (not fn*) so destructured arglists compile

Follow-up to the staged macro-compile change. The macro-recompile pass
wrapped each expander in the raw fn* primitive, which punts on a
destructuring rest param — so if-not/if-let/if-some/assert (using the
canonical '& [else]') couldn't compile and had been rewritten to plain
rest params as a workaround.

Root cause: fn* is the primitive; the fn MACRO is what desugars
destructuring (rest, map, nested) into the body before lowering. Wrapping
expanders in fn instead of fn* compiles any destructured macro arglist
uniformly, so the workaround is unnecessary — reverted those 4 macros to
the canonical '& [else]' forms.

Net: rest-destructuring is fully compiled for all normal code (fn/defn/
let/macro params). Only the hand-written raw fn* primitive still punts
(jolt-f79, downgraded to P4 — falls back to interpreter, still correct).

47/47 overlay macros compiled. 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, all unit+spec.

* core: fn*/let*/loop* are plain-symbol primitives, matching Clojure (jolt-f79)

jolt-f79 asked to compile destructuring in fn* rest params. Checking
against Clojure inverts the premise: Clojure's fn* REJECTS destructuring
at compile time ('fn params must be Symbols'; let*/loop* 'Bad binding
form, expected symbol'). So the self-hosted analyzer was already correct
— fn*/let*/loop* are plain-symbol primitives; the fn/let/loop/defn
MACROS desugar destructuring. The real defect was the interpreter
leniently destructuring raw fn*, and defn emitting raw fn* to rely on it.

Changes:
- evaluator: fn*/let*/loop* now reject non-symbol binding forms with
  Clojure's exact messages (require-symbol-params/plain-sym?), so the
  interpreter agrees with the analyzer + Clojure.
- 00-syntax: defn emits the fn MACRO (not raw fn*) so destructuring
  params desugar; unnamed, so self-recursion still resolves via the var.
- 00-syntax: completing that exposed a real gap — the overlay destructure
  fn didn't handle kwargs (a map pattern bound against a fn's sequential
  rest); it had only worked via the interpreter's destructure-bind. Added
  the seq->map coercion to the map? branch (sequential: 1 map elt => that
  map, else apply hash-map), matching destructure-bind so interpret ==
  compile.

Net: fn*/let*/loop* are plain-symbol primitives across interpreter,
analyzer, and Clojure; all real destructuring (fn/defn/let/loop/macro
params, incl kwargs & {:keys}) compiles through the macros with no
interpreter fallback. Regression spec added.

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 (destructuring 50/50).

* docs: clarify fn*/let*/loop* take plain symbols only (jolt-f79)

grammar.ebnf: the destructuring note already attributed patterns to the
binding MACROS; make the boundary explicit — the fn*/let*/loop* PRIMITIVES
they desugar to take plain symbols only (a non-symbol binding errors, as
in Clojure).

self-hosting-compiler.md: the 'compile destructuring via a shared
destructure expander instead of falling back' item is done (and its
jolt-7dl ref was stale) — destructuring now compiles through the
fn/let/loop/defn macros' desugaring; the primitives reject patterns.

* core: Stage 2 Task 2 tier 1 — compile syntax-quote + definterface/extend/proxy

First slice of moving stateful forms onto the compile path (jolt-eaa).
- loader stateful-head?: drop syntax-quote (the analyzer's `handled` set
  already compiles it; routing it to the interpreter was redundant).
- host_iface special-names: drop definterface/extend/proxy (stub macros
  expanding to def/nil — their expansions compile once unpunted).
- letfn stays interpreted: its let* expansion needs letrec semantics
  (mutual recursion between the fns), which sequential compiled let* lacks
  — a later tier.

Gate green: conformance 267x3, fallback-zero 31/5, bootstrap-fixpoint
stage1==2==3, self-host, staged-bootstrap, clojure-test-suite >=4034/67,
features 78/78, all unit + protocol/multimethod/macro specs.

---------

Co-authored-by: Yogthos <yogthos@gmail.com>

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

@@ -102,11 +102,24 @@
                    (vloop 0 0 (conj (conj acc g) init)))
                (map? pat)
                  (let* [g (symbol (str (gensym)))
+                        gm (symbol (str (gensym)))
+                        ;; kwargs: a map pattern may bind against the sequential rest
+                        ;; of a fn — (& {:keys [...]}) — which is a seq of alternating
+                        ;; k/v args, or a single trailing map. Coerce like Clojure (and
+                        ;; like the interpreter's destructure-bind, so interpret/compile
+                        ;; agree): a sequential value with one map element is that map,
+                        ;; otherwise (apply hash-map). A real map value is used as-is, so
+                        ;; ordinary map destructuring is unaffected. g holds init once;
+                        ;; gm is the coerced map every lookup (and :as) reads from.
+                        coerce `(if (sequential? ~g)
+                                  (if (and (= 1 (count ~g)) (map? (first ~g)))
+                                    (first ~g)
+                                    (apply hash-map ~g))
+                                  ~g)
                         or-map (get pat :or)
                         as-sym (get pat :as)
-                        base (if as-sym
-                               (conj (conj (conj (conj acc g) init) as-sym) g)
-                               (conj (conj acc g) init))
+                        bound (conj (conj (conj (conj acc g) init) gm) coerce)
+                        base (if as-sym (conj (conj bound as-sym) gm) bound)
                         group
                           (fn* [a kw kind]
                             (let* [names (get pat kw)]
@@ -125,8 +138,8 @@
                                            fo (find-or or-map local)]
                                       (conj (conj aa (symbol local))
                                             (if (nth fo 0)
-                                              `(get ~g ~keyform ~(nth fo 1))
-                                              `(get ~g ~keyform)))))
+                                              `(get ~gm ~keyform ~(nth fo 1))
+                                              `(get ~gm ~keyform)))))
                                   a names)
                                 a)))
                         g1 (group base :keys :kw)
@@ -135,7 +148,7 @@
                    (reduce (fn* [a k]
                              (if (keyword? k)
                                a
-                               (proc k `(get ~g ~(get pat k)) a)))
+                               (proc k `(get ~gm ~(get pat k)) a)))
                            g3 (keys pat)))
                :else (throw (str "unsupported destructuring pattern"))))
          ploop
@@ -212,8 +225,11 @@
       (let [as (vec (map mk aftn))]
         (if nm `(fn* ~nm ~@as) `(fn* ~@as))))))
 
-;; defn: drop an optional leading docstring and attr-map, then (def name (fn* ...)).
-;; Both single- and multi-arity reduce to (fn* ~@body) — fn* takes either a params
+;; defn: drop an optional leading docstring and attr-map, then (def name (fn ...)).
+;; Emits the fn MACRO (not the fn* primitive) so destructuring params desugar — fn*
+;; requires plain symbols (like Clojure). Unnamed (as before): self-recursion
+;; resolves through the def'd var, so this only adds the desugaring step.
+;; Both single- and multi-arity reduce to (fn ~@body) — fn takes either a params
 ;; vector + body or a sequence of ([params] body) clauses, so no arity branching is
 ;; needed. (map? is true for symbol forms too, so guard the attr-map with symbol?.)
 ;; Defined before fresh-sym below, which is a defn-.
@@ -221,7 +237,7 @@
   (let [body (if (and (seq body) (string? (first body))) (rest body) body)
         body (if (and (seq body) (map? (first body)) (not (symbol? (first body))))
                (rest body) body)]
-    `(def ~fn-name (fn* ~@body))))
+    `(def ~fn-name (fn ~@body))))
 
 ;; Jolt doesn't enforce privacy, so defn- is just defn (matching how Clojure's own
 ;; defn- delegates to defn with :private metadata).