mk: phase 4A — appendo canary green, both directions

Three coupled fixes plus a new relations module land together because
each is required for the next: appendo can't terminate without all
three.

1. unify.sx — added (:cons h t) tagged cons-cell shape because SX has no
   improper pairs. The unifier treats (:cons h t) and the native list
   (h . t) as equivalent. mk-walk* re-flattens cons cells back to flat
   lists for clean reification.

2. stream.sx — switched mature stream cells from plain SX lists to a
   (:s head tail) tagged shape so a mature head can have a thunk tail.
   With the old representation, mk-mplus had to (cons head thunk) which
   SX rejects (cons requires a list cdr).

3. conde.sx — wraps each clause in Zzz (inverse-eta delay) for laziness.
   Zzz uses (gensym "zzz-s-") for the substitution parameter so it does
   not capture user goals that follow the (l s ls) convention. Without
   gensym, every relation that uses `s` as a list parameter silently
   binds it to the substitution dict.

relations.sx is the new module: nullo, pairo, caro, cdro, conso,
firsto, resto, listo, appendo, membero. 25 new tests.

Canary green:
  (run* q (appendo (list 1 2) (list 3 4) q))
    → ((1 2 3 4))
  (run* q (fresh (l s) (appendo l s (list 1 2 3)) (== q (list l s))))
    → ((() (1 2 3)) ((1) (2 3)) ((1 2) (3)) ((1 2 3) ()))
  (run 3 q (listo q))
    → (() (_.0) (_.0 _.1))

152/152 cumulative.

lib/minikanren/tests/conde.sx

@@ -1,93 +1,89 @@
 ;; lib/minikanren/tests/conde.sx — Phase 2 piece C tests for `conde`.
 ;;
-;; Note on ordering: mk-mplus only interleaves when the left stream is a
-;; paused thunk. Eager streams from == compose via mature DFS order
-;; (left-clause results first, then right-clause). True interleaving is
-;; tested in Phase 4 via recursive relations.
+;; Note on ordering: conde clauses are wrapped in Zzz (inverse-eta delay),
+;; so applying the conde goal to a substitution returns thunks. mk-mplus
+;; suspends-and-swaps when its left operand is paused, giving fair
+;; interleaving — this is exactly what makes recursive relations work,
+;; but it does mean conde answers can interleave rather than appear in
+;; strict left-to-right clause order.
 
 ;; --- single-clause conde ≡ conj of clause body ---
 
 (mk-test
   "conde-one-clause"
-  (let
-    ((q (mk-var "q")))
-    (let
-      ((res (stream-take 5 ((conde ((== q 7))) empty-s))))
-      (map (fn (s) (mk-walk q s)) res)))
+  (let ((q (mk-var "q"))) (run* q (conde ((== q 7)))))
   (list 7))
 
 (mk-test
   "conde-one-clause-multi-goals"
   (let
     ((q (mk-var "q")))
-    (let
-      ((res (stream-take 5 ((conde ((fresh (x) (== x 5) (== q (list x x))))) empty-s))))
-      (map (fn (s) (mk-walk* q s)) res)))
+    (run* q (conde ((fresh (x) (== x 5) (== q (list x x)))))))
   (list (list 5 5)))
 
-;; --- multi-clause: produces one row per clause (eager DFS order) ---
+;; --- multi-clause: produces one row per clause (interleaved) ---
 
 (mk-test
-  "conde-three-clauses"
+  "conde-three-clauses-as-set"
   (let
-    ((q (mk-var "q")))
-    (let
-      ((res (stream-take 10 ((conde ((== q 1)) ((== q 2)) ((== q 3))) empty-s))))
-      (map (fn (s) (mk-walk q s)) res)))
-  (list 1 2 3))
+    ((qs (run* q (conde ((== q 1)) ((== q 2)) ((== q 3))))))
+    (and
+      (= (len qs) 3)
+      (and
+        (some (fn (x) (= x 1)) qs)
+        (and
+          (some (fn (x) (= x 2)) qs)
+          (some (fn (x) (= x 3)) qs)))))
+  true)
 
 (mk-test
-  "conde-mixed-success-failure"
+  "conde-mixed-success-failure-as-set"
   (let
-    ((q (mk-var "q")))
-    (let
-      ((res (stream-take 10 ((conde ((== q "a")) ((== 1 2)) ((== q "b"))) empty-s))))
-      (map (fn (s) (mk-walk q s)) res)))
-  (list "a" "b"))
+    ((qs (run* q (conde ((== q "a")) ((== 1 2)) ((== q "b"))))))
+    (and
+      (= (len qs) 2)
+      (and (some (fn (x) (= x "a")) qs) (some (fn (x) (= x "b")) qs))))
+  true)
 
 ;; --- conde with conjuncts inside clauses ---
 
 (mk-test
-  "conde-clause-conj"
+  "conde-clause-conj-as-set"
   (let
-    ((q (mk-var "q")) (r (mk-var "r")))
-    (let
-      ((res (stream-take 10 ((conde ((== q 1) (== r 10)) ((== q 2) (== r 20))) empty-s))))
-      (map (fn (s) (list (mk-walk q s) (mk-walk r s))) res)))
-  (list (list 1 10) (list 2 20)))
-
-;; --- conde + fresh: multiple solutions per clause ---
-
-(mk-test
-  "conde-with-fresh-and-disj"
-  (let
-    ((q (mk-var "q")))
-    (let
-      ((res (stream-take 10 ((conde ((fresh (x) (mk-disj (== x 1) (== x 2)) (== q x))) ((== q 100))) empty-s))))
-      (map (fn (s) (mk-walk q s)) res)))
-  (list 1 2 100))
+    ((rows (run* q (fresh (x y) (conde ((== x 1) (== y 10)) ((== x 2) (== y 20))) (== q (list x y))))))
+    (and
+      (= (len rows) 2)
+      (and
+        (some (fn (r) (= r (list 1 10))) rows)
+        (some (fn (r) (= r (list 2 20))) rows))))
+  true)
 
 ;; --- nested conde ---
 
 (mk-test
-  "conde-nested"
+  "conde-nested-yields-three"
   (let
-    ((q (mk-var "q")))
-    (let
-      ((res (stream-take 10 ((conde ((conde ((== q 1)) ((== q 2)))) ((== q 3))) empty-s))))
-      (map (fn (s) (mk-walk q s)) res)))
-  (list 1 2 3))
+    ((qs (run* q (conde ((conde ((== q 1)) ((== q 2)))) ((== q 3))))))
+    (and
+      (= (len qs) 3)
+      (and
+        (some (fn (x) (= x 1)) qs)
+        (and
+          (some (fn (x) (= x 2)) qs)
+          (some (fn (x) (= x 3)) qs)))))
+  true)
 
 ;; --- conde all clauses fail → empty stream ---
 
 (mk-test
   "conde-all-fail"
-  ((conde ((== 1 2)) ((== 3 4)))
-    empty-s)
+  (run*
+    q
+    (conde ((== 1 2)) ((== 3 4))))
   (list))
 
 ;; --- empty conde: no clauses ⇒ fail ---
 
-(mk-test "conde-no-clauses" ((conde) empty-s) (list))
+(mk-test "conde-no-clauses" (run* q (conde)) (list))
 
 (mk-tests-run!)