Small maps preserve insertion order

jolt maps were HAMTs with hash iteration order; Clojure keeps small maps as
PersistentArrayMap (insertion order), converting to PersistentHashMap past a
threshold. Map literals, array-map, assoc, into/transient, merge, zipmap,
select-keys, update-keys/vals, frequencies and group-by now iterate in insertion
order for <=8 entries, matching the JVM. hash-map and >8-entry maps stay hash
order; sets stay hash order.

The pmap record gains an order field (the insertion-order key list, or #f once
hashed); the HAMT still backs the values so equality/hash/lookup are unchanged.
pmap-fold visits an array-mode map last-to-first so the runtime's cons-accumulate
idiom reconstructs insertion order without touching its many call sites, and
hash-mode output stays byte-identical; pmap-fold-fwd visits in order for the few
sites that build a value directly. Transient maps track insertion order and
promote to hash past max(8, source-count), matching TransientArrayMap.

The hash-map native-op retargets to a hash-order builder so (hash-map ...) stays
hash-ordered while {...} literals are ordered; syntax-quote builds maps via the
hash builder (Clojure expands `{...} to apply hash-map). The core overlay map
builders seed from {} instead of (hash-map) to keep order.

Threshold is 8 for any key (the keyword exception in newer Clojure isn't in
1.12.5). honeysql now passes 832/0/0; 19 JVM-certified corpus rows added.

jolt-core/clojure/core/22-coll.clj

@@ -21,14 +21,15 @@
 (defn true? [x] (= true x))
 (defn false? [x] (= false x))
 
-;; Presence-preserving: a key with a nil value is kept ((hash-map) base keeps
-;; nil values and canonicalizes collection keys).
+;; Presence-preserving and order-preserving: a key with a nil value is kept, and
+;; the result follows keyseq order (an empty-map base keeps nil values and
+;; canonicalizes collection keys).
 (defn select-keys [map keyseq]
   (reduce (fn [m k] (if (contains? map k) (assoc m k (get map k)) m))
-          (hash-map) keyseq))
+          {} keyseq))
 
 (defn zipmap [keys vals]
-  (loop [m (hash-map) ks (seq keys) vs (seq vals)]
+  (loop [m {} ks (seq keys) vs (seq vals)]
     (if (and ks vs)
       (recur (assoc m (first ks) (first vs)) (next ks) (next vs))
       m)))
@@ -37,7 +38,7 @@
 ;; no-ops; all-nil (or no args) is nil.
 (defn merge [& maps]
   (when (some identity maps)
-    (reduce (fn [acc m] (if (nil? m) acc (conj (or acc (hash-map)) m)))
+    (reduce (fn [acc m] (if (nil? m) acc (conj (or acc {}) m)))
             maps)))
 
 (defn merge-with [f & maps]
@@ -49,7 +50,7 @@
                             (assoc m k (f (get m k) v))
                             (assoc m k v))))
           merge2 (fn [m1 m2]
-                   (reduce merge-entry (or m1 (hash-map)) (seq m2)))]
+                   (reduce merge-entry (or m1 {}) (seq m2)))]
       (reduce merge2 maps))))
 
 (defn get-in