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/clojure-stdlib/clojure/walk_test/walk.cljc

@@ -0,0 +1,101 @@
+(ns clojure.walk-test.walk
+  (:require [clojure.test :refer [deftest is testing]]
+            [clojure.walk :as w]))
+
+(deftest test-walk
+  (testing "walk with identity"
+    (is (= [1 2 3] (w/walk identity identity [1 2 3])))
+    (is (= '(1 2 3) (w/walk identity identity '(1 2 3))))
+    (is (= #{1 2 3} (w/walk identity identity #{1 2 3}))))
+
+  (testing "walk with inner transform"
+    (is (= [2 3 4] (w/walk inc identity [1 2 3])))
+    (is (= [2 3 4] (w/walk inc vec [1 2 3]))))
+
+  (testing "walk with outer transform"
+    (is (= [1 2 3] (w/walk identity vec '(1 2 3))))))
+
+(deftest test-postwalk
+  (testing "postwalk with numbers"
+    (is (= [2 3 4] (w/postwalk #(if (number? %) (inc %) %) [1 2 3]))))
+
+  (testing "postwalk with nested structures"
+    (is (= [2 [3 4] 5]
+           (w/postwalk #(if (number? %) (inc %) %) [1 [2 3] 4]))))
+
+  (testing "postwalk preserves types"
+    (is (vector? (w/postwalk identity [1 2 3])))
+    (is (list? (w/postwalk identity '(1 2 3))))
+    (is (set? (w/postwalk identity #{1 2 3})))
+    (is (map? (w/postwalk identity {:a 1 :b 2}))))
+
+  (testing "postwalk on maps"
+    (is (= {:a 2 :b 3}
+           (w/postwalk #(if (number? %) (inc %) %) {:a 1 :b 2}))))
+
+  (testing "postwalk on empty collections"
+    (is (= [] (w/postwalk identity [])))
+    (is (= {} (w/postwalk identity {})))
+    (is (= #{} (w/postwalk identity #{})))
+    (is (= '() (w/postwalk identity '())))))
+
+(deftest test-prewalk
+  (testing "prewalk with numbers"
+    (is (= [2 3 4] (w/prewalk #(if (number? %) (inc %) %) [1 2 3]))))
+
+  (testing "prewalk with nested structures"
+    (is (= [2 [3 4] 5]
+           (w/prewalk #(if (number? %) (inc %) %) [1 [2 3] 4]))))
+
+  (testing "prewalk transforms before descending"
+    ;; prewalk applies f to the outer form first, so we can replace
+    ;; entire subtrees before they are walked
+    (is (= [:replaced]
+           (w/prewalk #(if (= % [1 2 3]) [:replaced] %) [1 2 3])))))
+
+(deftest test-keywordize-keys
+  (testing "basic keywordize"
+    (is (= {:a 1 :b 2} (w/keywordize-keys {"a" 1 "b" 2}))))
+
+  (testing "nested keywordize"
+    (is (= {:a {:b 2}} (w/keywordize-keys {"a" {"b" 2}}))))
+
+  (testing "non-string keys unchanged"
+    (is (= {:a 1 42 2} (w/keywordize-keys {"a" 1 42 2}))))
+
+  (testing "already keyword keys unchanged"
+    (is (= {:a 1} (w/keywordize-keys {:a 1})))))
+
+(deftest test-stringify-keys
+  (testing "basic stringify"
+    (is (= {"a" 1 "b" 2} (w/stringify-keys {:a 1 :b 2}))))
+
+  (testing "nested stringify"
+    (is (= {"a" {"b" 2}} (w/stringify-keys {:a {:b 2}}))))
+
+  (testing "non-keyword keys unchanged"
+    (is (= {"a" 1 42 2} (w/stringify-keys {:a 1 42 2})))))
+
+(deftest test-postwalk-replace
+  (testing "basic replacement"
+    (is (= [:x :y :c] (w/postwalk-replace {:a :x :b :y} [:a :b :c]))))
+
+  (testing "nested replacement"
+    (is (= [:x [:y :c]] (w/postwalk-replace {:a :x :b :y} [:a [:b :c]]))))
+
+  (testing "no matches"
+    (is (= [1 2 3] (w/postwalk-replace {:a :x} [1 2 3]))))
+
+  (testing "empty smap"
+    (is (= [1 2 3] (w/postwalk-replace {} [1 2 3])))))
+
+(deftest test-prewalk-replace
+  (testing "basic replacement"
+    (is (= [:x :y :c] (w/prewalk-replace {:a :x :b :y} [:a :b :c]))))
+
+  (testing "nested replacement"
+    (is (= [:x [:y :c]] (w/prewalk-replace {:a :x :b :y} [:a [:b :c]]))))
+
+  (testing "replaces before descending"
+    ;; prewalk-replace replaces the whole form first, then walks children
+    (is (= :replaced (w/prewalk-replace {[:a :b] :replaced} [:a :b])))))