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/api.sx

@@ -112,7 +112,8 @@
           (let
             ((existing (get (get db :facts) rel-key))
               (kept (list))
-              (kept-keys {}))
+              (kept-keys {})
+              (kept-index {}))
             (do
               (for-each
                 (fn
@@ -121,10 +122,19 @@
                     (not (dl-tuple-equal? t lit))
                     (do
                       (append! kept t)
-                      (dict-set! kept-keys (dl-tuple-key t) true))))
+                      (dict-set! kept-keys (dl-tuple-key t) true)
+                      (when
+                        (>= (len t) 2)
+                        (let ((k (dl-arg-key (nth t 1))))
+                          (do
+                            (when
+                              (not (has-key? kept-index k))
+                              (dict-set! kept-index k (list)))
+                            (append! (get kept-index k) t)))))))
                 existing)
               (dict-set! (get db :facts) rel-key kept)
-              (dict-set! (get db :facts-keys) rel-key kept-keys))))
+              (dict-set! (get db :facts-keys) rel-key kept-keys)
+              (dict-set! (get db :facts-index) rel-key kept-index))))
         ;; Wipe all relations that have a rule (these are IDB) so the
         ;; saturator regenerates them from the surviving EDB.
         (let ((rule-heads (dl-rule-head-rels db)))
@@ -133,7 +143,8 @@
               (k)
               (do
                 (dict-set! (get db :facts) k (list))
-                (dict-set! (get db :facts-keys) k {})))
+                (dict-set! (get db :facts-keys) k {})
+                (dict-set! (get db :facts-index) k {})))
             rule-heads))
         (dl-saturate! db)
         db))))