datalog: first-arg index per relation (Phase 5e perf, 169/169)

db gains :facts-index {<rel>: {<first-arg-key>: tuples}} mirroring
the membership :facts-keys index. dl-add-fact! populates the index;
dl-match-positive walks the body literal's first arg under the
current subst — when it's bound to a non-var, look up by (str arg)
instead of scanning the full relation.

For chain-style recursive rules (parent X Y), (ancestor Y Z) the
inner Y has at most one parent, so the inner lookup returns 0–1
tuples instead of N. chain-25 saturation drops from ~33s to ~18s
real (~2x). chain-50 still long but tractable; next bottleneck is
subst dict copies during unification.

dl-retract! refreshed to keep the new index consistent: kept-index
rebuilt during EDB filter, IDB wipes clear all three slots.

Differential semi-naive test bumped to chain-12, semi-only count
test to chain-25.

lib/datalog/db.sx

@@ -12,7 +12,7 @@
 ;; lib/datalog/builtins.sx) swaps in the real `dl-rule-check-safety`,
 ;; which is order-aware and understands built-in predicates.
 
-(define dl-make-db (fn () {:facts {} :facts-keys {} :rules (list)}))
+(define dl-make-db (fn () {:facts {} :facts-keys {} :facts-index {} :rules (list)}))
 
 (define
   dl-rel-name
@@ -98,7 +98,8 @@
     (db rel-key)
     (let
       ((facts (get db :facts))
-        (fk (get db :facts-keys)))
+        (fk (get db :facts-keys))
+        (fi (get db :facts-index)))
       (do
         (when
           (not (has-key? facts rel-key))
@@ -106,8 +107,51 @@
         (when
           (not (has-key? fk rel-key))
           (dict-set! fk rel-key {}))
+        (when
+          (not (has-key? fi rel-key))
+          (dict-set! fi rel-key {}))
         (get facts rel-key)))))
 
+;; First-arg index helpers. Tuples are keyed by their first-after-rel
+;; arg's `(str ...)`; when that arg is a constant, dl-match-positive
+;; uses the index instead of scanning the full relation.
+(define
+  dl-arg-key
+  (fn
+    (v)
+    (str v)))
+
+(define
+  dl-index-add!
+  (fn
+    (db rel-key lit)
+    (let
+      ((idx (get db :facts-index))
+        (n (len lit)))
+      (when
+        (and (>= n 2) (has-key? idx rel-key))
+        (let
+          ((rel-idx (get idx rel-key))
+            (k (dl-arg-key (nth lit 1))))
+          (do
+            (when
+              (not (has-key? rel-idx k))
+              (dict-set! rel-idx k (list)))
+            (append! (get rel-idx k) lit)))))))
+
+(define
+  dl-index-lookup
+  (fn
+    (db rel-key arg-val)
+    (let
+      ((idx (get db :facts-index)))
+      (cond
+        ((not (has-key? idx rel-key)) (list))
+        (else
+          (let ((rel-idx (get idx rel-key))
+                (k (dl-arg-key arg-val)))
+            (if (has-key? rel-idx k) (get rel-idx k) (list))))))))
+
 (define dl-tuple-key (fn (lit) (str lit)))
 
 (define
@@ -140,6 +184,7 @@
                 (do
                   (dict-set! key-dict tk true)
                   (append! tuples lit)
+                  (dl-index-add! db rel-key lit)
                   true)))))))))
 
 ;; The full safety check lives in builtins.sx (it has to know which