core: three bug fixes — ifn?, prefer-method dispatch, reader comments in map values

ifn? (jolt-1vx) is the canonical IFn set in the overlay: fns, keywords,
symbols, maps (sorted included), sets, vectors, and vars — NOT lists. The
seed version said true for lists and false for struct maps and vars.
Mutable-mode caveat documented (vectors and lists share the array repr
there). 13 predicate rows.

Multimethod dispatch (jolt-heo) now collects EVERY isa-matching method key
and picks the dominant one — x dominates y when prefer-method'd over it or
(isa? x y) — and two matches with no dominant is an ambiguity ERROR, as in
Clojure. It used to take whichever key the table yielded first, silently
ignoring prefer-method. The prefers store upgrades to Clojure's
{x -> set-of-dominated} shape, shared between the dispatch closure and
prefer-method-setup via the var; prefers becomes a macro over a setup fn
(the store lives on the VAR — the multifn value can't carry it, so the old
fn read {} forever). 6 multimethod rows + the conformance row updated to
the canonical shape (335x3).

The reader (jolt-ou8) kept the pending KEY when a comment or #_ sits in a
map's VALUE slot: the old code dropped both, desyncing kv pairing — the
real value became the next key and the closing brace landed in value
position ('Unmatched closing brace'). Selmer's deps.edn (a '; for
development (REPL, etc)' comment between key and value) now parses; 6
reader rows incl. nested commented maps.

Gate: jpm exit 0, conformance 335x3, all tests passed.

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

@@ -838,3 +838,10 @@
      ([x y z] (f (g x y z)))
      ([x y z & args] (f (apply g x y z args)))))
   ([f g & fs] (reduce comp (comp f g) fs)))
+
+;; Canonical IFn set (jolt-1vx): fns, keywords, symbols, maps (sorted incl.),
+;; sets, vectors, and vars — NOT lists ((ifn? '(1 2)) is false in Clojure).
+;; Mutable-mode caveat: vectors and lists share the array representation
+;; there, so vector? can't separate them and lists read as ifn?.
+(defn ifn? [x]
+  (or (fn? x) (keyword? x) (symbol? x) (map? x) (set? x) (vector? x) (var? x)))

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

@@ -45,6 +45,11 @@
 (defmacro methods [mm]
   `(methods-setup (quote ~mm)))
 
+;; prefers reads the store off the VAR (the multifn value can't carry it) —
+;; same symbol-passing shape as the other multimethod table ops.
+(defmacro prefers [mm]
+  `(prefers-setup (quote ~mm)))
+
 ;; instance?: class names don't evaluate to values on jolt, so the type arg is
 ;; passed quoted to the ctx-capturing checker; the value evaluates normally.
 (defmacro instance? [t x]