Enable IR inlining: splice small defns at call sites (lever 1/4)

jolt.passes.inline was fully written but dormant — it fetched bodies via the
inline-ir host hook, which was a stub returning nil. Wire it up: run-passes stashes
each inline-eligible defn (single fixed arity) as its form is optimized, and
inline-ir hands the body back at call sites under --opt.

The catch was the ^double/^long coercion: an inlined fn drops its param-entry and
return coercion, so (work 3 4) on a ^double fn would return 25 instead of 25.0. New
:coerce IR node carries the coercion inside the spliced body — the inline pass wraps
a hinted param's arg and the return in :coerce, the back end lowers it
(exact->inexact / jolt->fx), and jolt.passes.numeric reads its :kind. So an inlined
call matches the called one and the body's fl*/fx* fast path still fires.

Only under --opt (closed world); the seed mint and -e don't inline, so selfhost and
the corpus are unaffected. test/chez/inline-test.ss 12/12 (make inline); full make
test green, 0 new corpus divergences.

Bench (hot loop, body is a ^double helper call): direct-link 500ms -> --opt
(inlined) 184ms = 2.7x, by eliminating the call + coercion wrappers and letting Chez
fuse the fl-ops unboxed. ~26x over the default dispatched build.

jolt-core/jolt/ir.clj

@@ -66,6 +66,13 @@
 (defn quote-node [form] {:op :quote :form form})
 (defn throw-node [expr] {:op :throw :expr expr})
 
+;; Numeric coercion of a value to a primitive kind (:double / :long), the way a JVM
+;; ^double/^long parameter or return coerces. The back end lowers it (exact->inexact
+;; / jolt->fx) and jolt.passes.numeric reads its :kind as the value's numeric kind.
+;; Carrying coercion as an IR node (rather than a back-end string wrap) lets it
+;; travel with inlining and keeps the typed-arithmetic fast path sound.
+(defn coerce-node [kind expr] {:op :coerce :kind kind :expr expr})
+
 ;; ---------------------------------------------------------------------------
 ;; Structural recursion over IR child nodes.
 ;;
@@ -91,6 +98,7 @@
       (= op :do)     (assoc node :statements (mapv f (get node :statements))
                                  :ret (f (get node :ret)))
       (= op :throw)  (assoc node :expr (f (get node :expr)))
+      (= op :coerce) (assoc node :expr (f (get node :expr)))
       (= op :set-var) (assoc node :val (f (get node :val)))
       (= op :set-field) (assoc node :obj (f (get node :obj)) :val (f (get node :val)))
       (= op :defmacro) (assoc node :fn (f (get node :fn)))
@@ -138,6 +146,7 @@
       (= op :if) (f (f (f acc (get node :test)) (get node :then)) (get node :else))
       (= op :do) (f (reduce f acc (get node :statements)) (get node :ret))
       (= op :throw) (f acc (get node :expr))
+      (= op :coerce) (f acc (get node :expr))
       (= op :set-var) (f acc (get node :val))
       (= op :set-field) (f (f acc (get node :obj)) (get node :val))
       (= op :defmacro) (f acc (get node :fn))