core: migrate repeatedly to Clojure + fix char-not-callable / take count validation

Resolves the deferred repeatedly port (jolt-8qx). The blockers were two jolt
leniencies vs Clojure, now fixed (and correct beyond repeatedly):

- A char (a :jolt/type-tagged struct) fell into the struct-as-map branch of both
  jolt-call (compile path) and the interpreter's apply dispatch, so (\a) returned
  nil instead of throwing. Now only an UNtagged struct (a map literal) — or a
  record — is callable as a key lookup; tagged structs fall through to "Cannot
  call … as a function". Symbols are still handled (keyword-style get).
- core-take didn't validate its count, letting Janet's >= silently compare an int
  to a char/string. It now rejects a non-number n like Clojure.

With those, the canonical CLJ repeatedly matches: (first (repeatedly non-fn)) and
(repeatedly non-number f) throw. Moved repeatedly to core/40-lazy.clj; removed
core-repeatedly + its binding from the seed.

These correctness fixes help broadly: repeatedly.cljc goes clean (19/10 -> 29/0),
and the suite rises 4004 -> 4034 pass / 66 -> 67 clean. Baseline raised.

Gate: conformance 262x3, lazy-infinite 44/44, clojure-test-suite 4034/67,
fixpoint, self-host, sci, fallback-zero, specs+unit green.

jolt-core/clojure/core/40-lazy.clj

@@ -85,10 +85,12 @@
         (cstep 0)))
     ()))
 
-;; repeatedly stays in the Janet seed for now (core-repeatedly): the canonical CLJ
-;; version doesn't validate args, so (first (repeatedly non-fn)) / (repeatedly \a +)
-;; don't throw like the stricter Janet version (repeatedly.cljc throw cases).
-;; Ported separately once the non-fn / non-number-count throws are matched.
+;; --- repeatedly --- ((f) throws on a non-fn; (take n …) throws on a non-number
+;; count — both now enforced in the seed (jolt-call / core-take), so the canonical
+;; CLJ form matches the repeatedly.cljc exception cases.)
+(defn repeatedly
+  ([f] (lazy-seq (cons (f) (repeatedly f))))
+  ([n f] (take n (repeatedly f))))
 
 ;; --- repeat ---
 (defn repeat