General fixes shaken out by running core.logic's test suite

Running clojure/core.logic's own suite surfaced a batch of general jolt gaps.
None are core.logic-specific; each is a language/host behavior that was wrong or
missing. With these, the core relational engine (unify, run/fresh/conde,
conso/membero/appendo, reification to _0/_1, lcons) runs; the remaining failures
are in core.logic's constraint-logic-programming and finite-domain layers
(tracked separately).

- analyzer: accept the list-member dot form (. target (method args)), sugar for
  (. target method args). Re-mint.
- identical? is reference identity (eq?), not value equality. It was aliased to =,
  which infinite-loops when a deftype's .equals short-circuits on (identical? this o)
  (core.logic's Substitutions) and is wrong for distinct equal collections.
- jrecs use a deftype's declared hashCode/equals/equiv for map/set keying instead
  of structural field comparison, so metadata-wrapped keys still match (core.logic
  keys substitutions on lvar id, ignoring metadata).
- meta/with-meta dispatch to a deftype's clojure.lang.IObj meta/withMeta methods
  when present, so metadata threaded through the type's own assoc/withMeta survives
  (previously kept in an identity side-table the reconstructed instances didn't share).
- coll?/seqable? on a deftype require IPersistentCollection (cons) or ISeq (first);
  ILookup(valAt)/Indexed(nth)/Counted(count)/Seqable(seq) alone no longer qualify,
  matching the JVM.
- syntax-quote resolves a bare symbol to the compile ns's own def before
  clojure.core, so a name the ns excluded and redefined (core.logic's == after
  :refer-clojure :exclude) qualifies correctly in macro output.
- reader: record literals #ns.Type{...} / #ns.Type[...] expand to the map->/->
  factory call.
- structmap API: defstruct/create-struct/struct-map/struct/accessor (map-backed,
  insertion-ordered). Re-mint.
- .hashCode on strings/symbols (Java String.hashCode, Symbol Util.hashCombine);
  Class.isInstance; java.util.Collection.contains over vector/list/set;
  clojure.lang.RT/nextID and clojure.lang.Util hash/hasheq/equiv/identical statics.

corpus.edn: 8 JVM-certified rows. unit.edn: a Counted+Seqable deftype is coll?=false
(was a stale expectation encoding the old behavior).

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

@@ -34,6 +34,28 @@
       (recur (assoc m (first ks) (first vs)) (next ks) (next vs))
       m)))
 
+;; Structmaps (legacy). A struct basis is the ordered vector of slot keys; a
+;; struct map is a plain map carrying every basis key (nil when unset), in basis
+;; order, so it looks up and compares like any other map.
+(defn create-struct [& keys] (vec keys))
+
+(defn struct-map [basis & inits]
+  (let [base (loop [m {} ks (seq basis)]
+               (if ks (recur (assoc m (first ks) nil) (next ks)) m))]
+    (loop [m base kvs (seq inits)]
+      (if kvs
+        (recur (assoc m (first kvs) (first (next kvs))) (next (next kvs)))
+        m))))
+
+(defn struct [basis & vals]
+  (loop [m (struct-map basis) ks (seq basis) vs (seq vals)]
+    (if (and ks vs)
+      (recur (assoc m (first ks) (first vs)) (next ks) (next vs))
+      m)))
+
+(defn accessor [basis key]
+  (fn [m] (get m key)))
+
 ;; conj semantics per entry arg (a map merges, a [k v] pair adds); nil args are
 ;; no-ops; all-nil (or no args) is nil.
 (defn merge [& maps]

jolt-core/clojure/core/30-macros.clj

@@ -281,6 +281,10 @@
 ;; type's fields, bound from the instance (the method's first param), matching
 ;; Clojure's deftype scope. defrecord (below) expands to a bodyless (deftype …) and
 ;; handles its own methods, so this also serves the no-body case.
+;; Legacy structmap definer: binds a var to the struct basis (see create-struct).
+(defmacro defstruct [name & keys]
+  `(def ~name (create-struct ~@keys)))
+
 (defmacro deftype [tname fields & body]
   ;; strip ^meta off the type name and fields (the reader yields a (with-meta sym m)
   ;; form for e.g. (deftype ^{:doc …} Foo …)), so (name …) sees a bare symbol.