core: fn param + loop destructuring, compiled (matching Clojure)

fn now desugars destructuring params like Clojure's maybe-destructured: each
non-symbol param becomes a gensym and the body is wrapped in a let that rebinds the
pattern, so fn* only ever sees plain params and the COMPILER handles it (it rejected
patterns before, falling back to the interpreter). loop follows Clojure too: gensym
one loop var per binding, loop* over those, destructure via an inner let, with an
outer let so later inits see earlier destructured names — recur arity stays correct.

Two representation gotchas: build the param/binding vectors via [~@..] so they're
tuple forms (conj yields a pvec the analyzer rejects), and use (symbol (str
(gensym))) since a bare (gensym) in an overlay macro body is a Janet symbol the
destructurer rejects.

Closes the fn/loop destructuring gaps. conformance 228x3, fixpoint, clojure-test-
suite 3930, full suite green, bench flat.

test/spec/destructuring-spec.janet

@@ -43,6 +43,15 @@
   ["fn kwargs :or"      "9"      "(do (defn h [& {:keys [a] :or {a 9}}] a) (h))"]
   ["fn kwargs trailing map" "7"  "(do (defn k [& {:keys [a]}] a) (k {:a 7}))"])
 
+(defspec "destructure / fn params & loop"
+  ["fn vector param"    "7"      "((fn [[a b]] (+ a b)) [3 4])"]
+  ["fn map param"       "30"     "((fn [{:keys [x y]}] (* x y)) {:x 5 :y 6})"]
+  ["fn :or param"       "7"      "((fn [{:keys [x] :or {x 7}}] x) {})"]
+  ["fn multi-arity destr" "15"   "((fn ([[a]] a) ([[a] b] (+ a b))) [10] 5)"]
+  ["loop vector binding" "[4 2]" "(loop [[a b] [1 2] n 0] (if (< n 3) (recur [(inc a) b] (inc n)) [a b]))"]
+  ["loop map binding"   "4"      "(loop [{:keys [v]} {:v 1} n 0] (if (< n 2) (recur {:v (* v 2)} (inc n)) v))"]
+  ["loop init sees destr" "[1 2 3]" "(loop [[a b] [1 2] c (+ a b)] [a b c])"])
+
 (defspec "destructure / macro params"
   ["macro & [a & more :as all]"
    "[1 [2 3] [1 2 3]]"