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/data_test/diff.cljc

@@ -0,0 +1,149 @@
+(ns clojure.data-test.diff
+  (:require [clojure.test :refer [deftest is testing]]
+;; NOTE (jolt): sequential-diff expectations corrected to match real Clojure —
+;; clojure.data pads only to the max differing index (e.g. (diff [1 2 3] [1 9 3])
+;; -> a=[nil 2], not [nil 2 nil]). The upstream clojurust fixtures had this wrong.
+            [clojure.data :refer [diff]]))
+
+;; ── Atoms ────────────────────────────────────────────────────────────────────
+
+(deftest test-diff-equal-atoms
+  (testing "equal atoms"
+    (is (= [nil nil :a] (diff :a :a)))
+    (is (= [nil nil 1] (diff 1 1)))
+    (is (= [nil nil "hello"] (diff "hello" "hello")))
+    (is (= [nil nil nil] (diff nil nil)))
+    (is (= [nil nil true] (diff true true)))))
+
+(deftest test-diff-unequal-atoms
+  (testing "unequal atoms"
+    (is (= [:a :b nil] (diff :a :b)))
+    (is (= [1 2 nil] (diff 1 2)))
+    (is (= ["a" "b" nil] (diff "a" "b")))
+    (is (= [nil 1 nil] (diff nil 1)))
+    (is (= [true false nil] (diff true false)))))
+
+;; ── Maps ─────────────────────────────────────────────────────────────────────
+
+(deftest test-diff-equal-maps
+  (testing "equal maps"
+    (is (= [nil nil {:a 1 :b 2}] (diff {:a 1 :b 2} {:a 1 :b 2})))
+    (is (= [nil nil {}] (diff {} {})))))
+
+(deftest test-diff-maps-only-in-a
+  (testing "keys only in a"
+    (let [[a b both] (diff {:a 1 :b 2} {:a 1})]
+      (is (= {:b 2} a))
+      (is (nil? b))
+      (is (= {:a 1} both)))))
+
+(deftest test-diff-maps-only-in-b
+  (testing "keys only in b"
+    (let [[a b both] (diff {:a 1} {:a 1 :b 2})]
+      (is (nil? a))
+      (is (= {:b 2} b))
+      (is (= {:a 1} both)))))
+
+(deftest test-diff-maps-different-values
+  (testing "same keys, different values"
+    (let [[a b both] (diff {:a 1 :b 2} {:a 1 :b 9})]
+      (is (= {:b 2} a))
+      (is (= {:b 9} b))
+      (is (= {:a 1} both)))))
+
+(deftest test-diff-maps-nested
+  (testing "nested maps"
+    (let [[a b both] (diff {:a {:x 1 :y 2}} {:a {:x 1 :z 3}})]
+      (is (= {:a {:y 2}} a))
+      (is (= {:a {:z 3}} b))
+      (is (= {:a {:x 1}} both)))))
+
+(deftest test-diff-maps-disjoint
+  (testing "completely disjoint maps"
+    (let [[a b both] (diff {:a 1} {:b 2})]
+      (is (= {:a 1} a))
+      (is (= {:b 2} b))
+      (is (nil? both)))))
+
+;; ── Sets ─────────────────────────────────────────────────────────────────────
+
+(deftest test-diff-equal-sets
+  (testing "equal sets"
+    (is (= [nil nil #{1 2 3}] (diff #{1 2 3} #{1 2 3})))
+    (is (= [nil nil #{}] (diff #{} #{})))))
+
+(deftest test-diff-sets
+  (testing "overlapping sets"
+    (let [[a b both] (diff #{1 2 3} #{2 3 4})]
+      (is (= #{1} a))
+      (is (= #{4} b))
+      (is (= #{2 3} both)))))
+
+(deftest test-diff-disjoint-sets
+  (testing "disjoint sets"
+    (let [[a b both] (diff #{1 2} #{3 4})]
+      (is (= #{1 2} a))
+      (is (= #{3 4} b))
+      (is (nil? both)))))
+
+;; ── Vectors / Sequential ────────────────────────────────────────────────────
+
+(deftest test-diff-equal-vectors
+  (testing "equal vectors"
+    (is (= [nil nil [1 2 3]] (diff [1 2 3] [1 2 3])))
+    (is (= [nil nil []] (diff [] [])))))
+
+(deftest test-diff-vectors-same-length
+  (testing "same length, different elements"
+    (let [[a b both] (diff [1 2 3] [1 9 3])]
+      (is (= [nil 2] a))
+      (is (= [nil 9] b))
+      (is (= [1 nil 3] both)))))
+
+(deftest test-diff-vectors-different-length
+  (testing "different lengths"
+    (let [[a b both] (diff [1 2 3] [1 2])]
+      (is (= [nil nil 3] a))
+      (is (nil? b))
+      (is (= [1 2] both)))
+    (let [[a b both] (diff [1] [1 2 3])]
+      (is (nil? a))
+      (is (= [nil 2 3] b))
+      (is (= [1] both)))))
+
+(deftest test-diff-lists
+  (testing "lists treated as sequential"
+    (let [[a b both] (diff '(1 2 3) '(1 9 3))]
+      (is (= [nil 2] a))
+      (is (= [nil 9] b))
+      (is (= [1 nil 3] both)))))
+
+;; ── Mixed types ─────────────────────────────────────────────────────────────
+
+(deftest test-diff-mixed-types
+  (testing "different partition types treated as atoms"
+    (is (= [{:a 1} [1 2] nil] (diff {:a 1} [1 2])))
+    (is (= [#{1} [1] nil] (diff #{1} [1])))
+    (is (= [1 :a nil] (diff 1 :a)))))
+
+;; ── Nil handling ────────────────────────────────────────────────────────────
+
+(deftest test-diff-nil
+  (testing "nil vs non-nil"
+    (is (= [nil 1 nil] (diff nil 1)))
+    (is (= [1 nil nil] (diff 1 nil)))
+    (is (= [nil {:a 1} nil] (diff nil {:a 1})))))
+
+;; ── Deeply nested ───────────────────────────────────────────────────────────
+
+(deftest test-diff-deeply-nested
+  (testing "deeply nested structures"
+    (let [[a b both] (diff {:a {:b {:c 1}}} {:a {:b {:c 2}}})]
+      (is (= {:a {:b {:c 1}}} a))
+      (is (= {:a {:b {:c 2}}} b))
+      (is (nil? both))))
+  (testing "deeply nested with shared keys"
+    (let [[a b both] (diff {:a {:b 1 :c 2}} {:a {:b 1 :c 9}})]
+      (is (= {:a {:c 2}} a))
+      (is (= {:a {:c 9}} b))
+      (is (= {:a {:b 1}} both)))))