core: fix jolt-r81 at root — move lazy-seq/lazy-cat to the early syntax tier

Root cause: lazy-seq/lazy-cat were defined in 30-macros, which loads AFTER the
seq/coll tiers (10-seq, 20-coll) that use them. In compile mode a tier's forms
are compiled as the tier loads, so (lazy-seq …) in those tiers was compiled when
lazy-seq was not yet a registered macro — i.e. as a CALL to the macro-as-function,
which at runtime returns its own expansion `(make-lazy-seq (fn* [] …))` as data.
That leaked form then flowed into ops like `odd?` (partition-by) → type errors,
or silently produced wrong structure. Interpret/self-host masked it (expand at
call time); the eager fallbacks and the earlier letfn versions masked it by
falling back to the interpreter.

Fix: define lazy-seq/lazy-cat in 00-syntax (loaded first), exactly as when-let
already is for the same reason. They use only seed fns (make-lazy-seq/coll->cells/
concat) + map. With the macro registered early, the seq/coll tiers compile
(lazy-seq …) correctly.

With the root fixed, interleave/reductions/tree-seq drop their letfn workarounds
and use the canonical recursive Clojure forms (top-level / fn-self-name recursion
inside lazy-seq), verified leak-free in compile mode with strict probes.

Regression guards added: partition-by with odd? (the strict pred that exposed the
leak; the prior case used identity which masked it), reductions over an infinite
range, tree-seq summed through a strict filter — all ×3 modes.

Gate: conformance 249x3, lazy-infinite 40/40, fixpoint, self-host, specs+unit green.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

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

@@ -330,3 +330,16 @@
   (let [form (bindings 0) tst (bindings 1)]
     `(let [temp# ~tst]
        (if temp# (let [~form temp#] ~@body) nil))))
+
+;; lazy-seq / lazy-cat live here (not 30-macros) because the seq/coll tiers use
+;; them and compile-as-they-load: the macro must be registered before those tiers
+;; or (lazy-seq …) compiles to a call of the macro-as-function and leaks its
+;; expansion at runtime (jolt-r81). They use only seed fns (make-lazy-seq/
+;; coll->cells/concat) + map, all available from the start.
+;; lazy-seq defers its body: make-lazy-seq holds a thunk that realizes the body
+;; to cells when forced. lazy-cat wraps each coll in a lazy-seq and concats.
+(defmacro lazy-seq [& body]
+  `(make-lazy-seq (fn* [] (coll->cells (do ~@body)))))
+
+(defmacro lazy-cat [& colls]
+  `(concat ~@(map (fn [c] `(lazy-seq ~c)) colls)))