datalog: dl-walk handles circular substitutions without infinite loop (257/257)

Bug: dl-walk would infinite-loop on a circular substitution
(e.g. A→B and B→A simultaneously). The walk endlessly chased
the cycle. This couldn't be produced through dl-unify (which has
cycle-safe behavior via existing bindings), but raw dl-bind calls
or external manipulation of the subst dict could create it.

Fix: dl-walk now threads a visited-names list through the
recursion. If a variable name is already in the list, the walk
stops and returns the current term unchanged. Normal chained
walks are unaffected (A→B→C→42 still resolves to 42).

1 new unify test verifies circular substitutions don't hang.

lib/datalog/unify.sx

@@ -33,16 +33,28 @@
 ;; variable. The result is either a non-variable term or an unbound var.
 (define
   dl-walk
+  (fn (term subst) (dl-walk-aux term subst (list))))
+
+;; Internal: walk with a visited-var set so circular substitutions
+;; (from raw dl-bind misuse) don't infinite-loop. Cycles return the
+;; current term unchanged.
+(define
+  dl-walk-aux
   (fn
-    (term subst)
+    (term subst visited)
     (if
       (dl-var? term)
       (let
         ((name (symbol->string term)))
-        (if
-          (and (dict? subst) (has-key? subst name))
-          (dl-walk (get subst name) subst)
-          term))
+        (cond
+          ((dl-member? name visited) term)
+          ((and (dict? subst) (has-key? subst name))
+            (let ((seen (list)))
+              (do
+                (for-each (fn (v) (append! seen v)) visited)
+                (append! seen name)
+                (dl-walk-aux (get subst name) subst seen))))
+          (else term)))
       term)))
 
 ;; Bind a variable symbol to a value in subst, returning a new subst.