core: move the pure-leaf fns to the overlay; memfn is a real macro now

Round 3 of the seed shrink. To the overlay: identity, constantly, neg?,
even?, odd? (20-coll, ahead of their first in-tier uses), not= and unreduced
(00-syntax — the kernel and seq tiers use them), ==, ensure-reduced,
halt-when, parse-boolean, parse-uuid, newline, seque, array-seq, to-array-2d,
and the masking unchecked-byte/short/char/float/double coercions. parse-uuid
validates via re-matches over a new __make-uuid host binding (overlay source
can't write :jolt/type map literals). memfn moves to 30-macros as a working
macro over the .method call sugar instead of a fn that throws.

Behavior fixes toward Clojure, each with spec rows: == now throws on
non-numbers instead of comparing them, and halt-when is the canonical
::halt-map version (the halt value replaces the whole reduction result, no
double completion). list? and map-entry? stay in the seed — both are
representation-coupled (plist/tuple checks).

clojure-test-suite goes 4701 -> 4700: update.cljc expects
(update {:k 1} :k identity 1 2 3 4) to throw an arity error, and jolt fns
don't enforce fixed arity anywhere (pre-existing, language-wide — the seed's
Janet identity threw natively). Filed as jolt-6xn; fixing it should flip
several suite rows at once.

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

@@ -407,3 +407,10 @@
 ;; loads — so the macro must be registered BEFORE those tiers, else (lazy-seq …)
 ;; compiles as a call to the macro-as-function and leaks its expansion at runtime
 ;; (jolt-r81). They only need seed fns (make-lazy-seq/coll->cells/concat).
+
+;; memfn: a fn wrapping a method call, (memfn toUpperCase) => #(.toUpperCase %).
+;; The method symbol is rewritten to jolt's .method call sugar; extra arg names
+;; become fn params, as in Clojure.
+(defmacro memfn [method-name & args]
+  `(fn [target# ~@args]
+     (~(symbol (str "." (name method-name))) target# ~@args)))