clojure.string toString coercion; some-fn/ifn? reference semantics; misc host gaps

The clojure.string case fns and searches now take any Object s through its
toString like the reference's ^CharSequence signatures ((upper-case :kw) is
":KW", (capitalize 1) is "1"); nil throws, and a nil substr in
starts-with?/ends-with? throws. some-fn re-ported with the reference
arities: (some-fn) is an arity error and a no-match result is the last
predicate's own falsy value (false, not nil). ifn? covers multimethods,
promises (which are now invocable — calling one delivers, via a cold-path
invoke-arm registry that costs the hot dispatch nothing), and deftypes
implementing IFn's invoke.

One structural find on the way: defmulti/defmethod deferred inside a fn
body (the deftest pattern) interned/resolved in whatever namespace was
current when they RAN, not the one they were written in — the macros now
bake their expansion ns and the setups honor it.

Also: Boolean/Integer/Double wrapper ctors, primitive TYPE statics
(Integer/TYPE etc.), .reduce on collections (IReduce), and Long/TYPE.

cts baseline 5857 -> 5904 pass, 58 -> 28 errors, 57 baselined namespaces —
the string cluster, some-fn, ifn-qmark, boolean-qmark, and reduce
namespaces are all fully clean. 7 JVM-certified corpus rows; spec entry.

host/chez/seq.ss

@@ -436,6 +436,16 @@
 ;; can't statically resolve to a procedure (a keyword/coll/proc held in a local)
 ;; routes here. Off the arithmetic/self-recursion hot path by construction.
 ;; ============================================================================
+;; (pred . handler) arms making a host type invocable; handler gets (f args).
+(define jolt-invoke-arms '())
+(define (register-invoke-arm! pred handler)
+  (set! jolt-invoke-arms (cons (cons pred handler) jolt-invoke-arms)))
+(define (jolt-invoke-arm-for f)
+  (let loop ((as jolt-invoke-arms))
+    (cond ((null? as) #f)
+          (((caar as) f) (cdar as))
+          (else (loop (cdr as))))))
+
 (define (jolt-invoke f . args)
   (cond
     ((procedure? f) (apply f args))
@@ -449,6 +459,9 @@
      => (lambda (m) (apply jolt-invoke m f args)))
     ((and (reified-methods f) (hashtable-ref (reified-methods f) "invoke" #f))
      => (lambda (m) (apply jolt-invoke m f args)))
+    ;; host types registered as callable (promise delivers, …): consulted only
+    ;; after every built-in case missed, so the hot dispatch pays nothing.
+    ((jolt-invoke-arm-for f) => (lambda (h) (h f args)))
     ;; calling a non-fn: a ClassCastException naming the operator's CLASS (like
     ;; the JVM's "class clojure.lang.LazySeq cannot be cast to ... IFn" — never
     ;; the value, whose printed form may be unbounded: ((range)) must throw, not