feat: ~40 more core fns + fix map iteration to yield entries

While digging into test-load-sci, add genuinely-missing clojure.core fns:
doall/dorun/run!/tree-seq, key/val/map-entry?, rand-nth/replicate/
bounded-count/counted?/reversible?/seqable?, nat-int?/pos-int?/neg-int?/
double?/float?/ratio?/decimal?/rational?/numerator/denominator, list*,
special-symbol?/record?, promise/deliver, comparator/completing/halt-when/
ensure-reduced/unreduced, keyword-identical?/object?/tagged-literal/re-groups.

Fix a real pre-existing bug: iterating a map (first/seq/map/filter/reduce/vec/
realize-for-iteration) returned keys or values instead of [k v] entries.
Map literals are Janet structs (not phm), which several paths mishandled.
Now first/seq/realize-for-iteration yield entries for both structs and phms,
matching Clojure — e.g. (vec {:a 1}) => [[:a 1]], (map key m), (reduce f init m).

Tests: conformance 218/218 (+12), features 78/78, jank 120. Advances the SCI
bootstrap further (its clojure.core aggregation map resolves more symbols).

test/conformance.janet

@@ -106,6 +106,20 @@
    ["subvec"          "[2 3]"         "(subvec [1 2 3 4 5] 1 3)"]
    ["subvec to-end"   "[3 4 5]"       "(subvec [1 2 3 4 5] 2)"]
    ["reduce-kv"       "{:a 2 :b 3}"   "(reduce-kv (fn [m k v] (assoc m k (inc v))) {} {:a 1 :b 2})"]
+
+   ### ---- iterating maps yields entries ----
+   ["map over map"      "true"  "(= #{1 2} (set (map val {:a 1 :b 2})))"]
+   ["map keys over map" "true"  "(= #{:a :b} (set (map key {:a 1 :b 2})))"]
+   ["first of map"      "true"  "(let [e (first {:a 1})] (and (= (key e) :a) (= (val e) 1)))"]
+   ["vec of map"        "[[:a 1]]" "(vec {:a 1})"]
+   ["reduce over map"   "6"     "(reduce (fn [a [k v]] (+ a v)) 0 {:a 1 :b 2 :c 3})"]
+   ["into transform map" "{:a 2 :b 3}" "(into {} (map (fn [[k v]] [k (inc v)]) {:a 1 :b 2}))"]
+   ["filter over map"   "true"  "(= [[:b 2]] (filterv (fn [[k v]] (> v 1)) {:a 1 :b 2}))"]
+   ["doall realizes"    "(quote (2 3 4))" "(doall (map inc [1 2 3]))"]
+   ["tree-seq"          "(quote (1 2 3))" "(map (fn [x] x) (filter (complement coll?) (tree-seq coll? seq [1 [2 [3]]])))"]
+   ["key/val"           "true"  "(let [e [:k 9]] (and (= :k (key e)) (= 9 (val e))))"]
+   ["nat-int?"          "true"  "(and (nat-int? 0) (nat-int? 5) (not (nat-int? -1)))"]
+   ["list* prepend"     "(quote (1 2 3 4))" "(list* 1 2 [3 4])"]
    ["cycle"           "(quote (1 2 3 1 2 3 1))" "(take 7 (cycle [1 2 3]))"]
    ["partition-all"   "(quote ((1 2) (3 4) (5)))" "(partition-all 2 [1 2 3 4 5])"]
    ["reductions"      "(quote (1 3 6 10))" "(reductions + [1 2 3 4])"]