Fix direct-link crash on a non-fn var called as a function

Under --direct-link a top-level def binds jv$<fqn> and app->app calls bound directly
to it. emit-invoke raw-applied that binding for any var callee, but only a fn-valued
def is a Scheme procedure: (def cfg {...}) then (cfg :a) emitted (jv$cfg :a), applying
a pmap -> "attempt to apply non-procedure". Maps/sets/keywords are invokable in Clojure
via jolt-invoke, which the indirect path used, so this only bit closed-world builds.

Track which direct-linked vars hold fn literals (direct-link-fns, registered at the def
site when the init op is :fn) and only raw-apply those. A non-fn callee falls through to
the jolt-invoke branch, which still uses the direct jv$ binding as the invoke target —
so the var-deref is still skipped, just not the dispatch.

Seed source: re-minted. Regression in directlink-test.ss (jolt-cw1o).

jolt-core/jolt/backend_scheme.clj

@@ -109,7 +109,12 @@
 ;; set — one defined earlier in emission order (or itself), so the Scheme binding
 ;; exists by the time the reference runs. Reset per build.
 (def direct-link-defined (atom #{}))
-(defn direct-link-reset! [] (reset! direct-link-defined #{}))
+;; Of those, the ones whose init is a fn literal — safe to call as a raw Scheme
+;; application. A def of a non-fn value (a map, set, keyword, …) is invokable in
+;; Clojure but is not a Scheme procedure, so its calls must still route through
+;; jolt-invoke even with a direct binding.
+(def direct-link-fns (atom #{}))
+(defn direct-link-reset! [] (reset! direct-link-defined #{}) (reset! direct-link-fns #{}))
 
 ;; A direct-link Scheme binding name for a var. The fqn maps to a unique identifier
 ;; jv$<ns>$<name>; chars that break a Scheme identifier or the `$` separator are
@@ -120,6 +125,10 @@
 (defn- dl-fqn [ns nm] (str ns "/" nm))
 (defn- direct-linkable? [ns nm]
   (and @direct-link? (contains? @direct-link-defined (dl-fqn ns nm))))
+;; A direct-linked var whose value is a fn literal — its binding is a Scheme
+;; procedure, so a call site can apply it directly.
+(defn- direct-link-fn? [ns nm]
+  (contains? @direct-link-fns (dl-fqn ns nm)))
 
 ;; recur-target and the set of munged local names known to hold a procedure (a
 ;; named fn's self-recursion name) are lexically scoped — dynamic vars so the
@@ -486,9 +495,13 @@
       ;; a :local callee that isn't a known procedure -> dynamic IFn dispatch.
       (and (= :local (:op fnode)) (not (*known-procs* (munge-name (:name fnode)))))
       (invoke)
-      ;; closed-world direct call: the callee var is an app def already emitted with
-      ;; a Scheme binding — call it directly, no var lookup, no jolt-invoke.
-      (and (= :var (:op fnode)) (direct-linkable? (:ns fnode) (:name fnode)))
+      ;; closed-world direct call: the callee var is an app fn def already emitted
+      ;; with a Scheme binding — apply it directly, no var lookup, no jolt-invoke.
+      ;; Only fn-valued defs qualify; a non-fn invokable value (a map/set/keyword
+      ;; held in a var) isn't a Scheme procedure, so it falls through to jolt-invoke
+      ;; below (which still uses the direct binding as the invoke target).
+      (and (= :var (:op fnode)) (direct-linkable? (:ns fnode) (:name fnode))
+           (direct-link-fn? (:ns fnode) (:name fnode)))
       (order-args (fn [as] (str "(" (dl-name (:ns fnode) (:name fnode))
                                 (if (seq as) (str " " (str/join " " as)) "") ")")))
       ;; a late-bound :var call head can hold a procedure OR a non-applicable
@@ -636,6 +649,7 @@
     (let [ns (:ns node) nm (:name node) b (dl-name ns nm)]
       ;; register before emitting the init so a self-referential body direct-links.
       (swap! direct-link-defined conj (dl-fqn ns nm))
+      (when (= :fn (:op (:init node))) (swap! direct-link-fns conj (dl-fqn ns nm)))
       (let [init (emit (:init node))]
         (if (jmeta-nonempty? (:meta node))
           (str "(begin (define " b " " init ") (def-var-with-meta! "