core: Stage 3 — the *in* reader family is Clojure (50-io tier)

*in*, read-line, read, with-in-str, and line-seq land as a new overlay IO
tier (core/50-io.clj). *in* is a dynamic var holding a reader — a plain map
of two closures, :read-line-fn (next line, nil at EOF) and :read-fn (next
form, advancing past exactly that form). The default *in* reads real stdin
with a shared leftover buffer, so read and read-line interleave correctly;
with-in-str rebinds *in* to a string reader over one atom-held buffer —
(read) consumes its form, a following (read-line) returns the rest of that
line, as in Clojure. read has the 0/1/3 arities (EOF throws, or returns
eof-value when eof-error? is false).

The Janet seed grows two seams next to read-string: __stdin-read-line (one
line off stdin, newline stripped) and __parse-next (one form off a string ->
[form rest], nil at end of input) — and loses the line-seq stub.

Two traps hit and documented for future tiers: a map LITERAL with :jolt/type
as a key is read as a tagged form (don't tag overlay value maps), and a
leftover seed stub holding the same name breaks direct-linked self-recursion
— the overlay line-seq's recursive call bound to the stub's root, truncating
after one line. The stub's string-splitting behavior is kept as a documented
extension.

20 new io-spec rows (read-line EOF/interleave, read arities + eval round-trip,
line-seq incl. real-stdin paths). Gate green: conformance 326x3, suite 4577,
full jpm test.

test/spec/io-spec.janet

@@ -24,3 +24,33 @@
   ["str of coll"     "\"[1 2]\""   "(str [1 2])"]
   ["format d/s"      "\"5-x\""     "(format \"%d-%s\" 5 \"x\")"]
   ["format float"    "\"3.14\""    "(format \"%.2f\" 3.14159)"])
+
+# The *in* reader family (jolt-0d9): *in* is a dynamic var holding a reader;
+# with-in-str rebinds it to a string reader over one shared buffer, so read
+# (consumes exactly one form) and read-line (rest of that line) interleave
+# correctly, as in Clojure.
+(defspec "io / *in* + with-in-str + read-line"
+  ["read-line one line"   "\"hello\""        "(with-in-str \"hello\" (read-line))"]
+  ["read-line strips nl"  "\"a\""            "(with-in-str \"a\\nb\" (read-line))"]
+  ["read-line sequential" "[\"a\" \"b\"]"    "(with-in-str \"a\\nb\" [(read-line) (read-line)])"]
+  ["read-line EOF nil"    "nil"              "(with-in-str \"\" (read-line))"]
+  ["read-line after last" "[\"x\" nil]"      "(with-in-str \"x\" [(read-line) (read-line)])"]
+  ["empty line"           "[\"\" \"y\"]"     "(with-in-str \"\\ny\" [(read-line) (read-line)])"]
+  ["*in* is bound"        "true"             "(with-in-str \"\" (map? *in*))"])
+
+(defspec "io / read"
+  ["read a form"          "42"               "(with-in-str \"42\" (read))"]
+  ["read a list form"     "(quote (+ 1 2))"  "(with-in-str \"(+ 1 2)\" (read))"]
+  ["read two forms"       "[1 2]"            "(with-in-str \"1 2\" [(read) (read)])"]
+  ["read then read-line"  "[1 \" rest\"]"    "(with-in-str \"1 rest\\nnext\" [(read) (read-line)])"]
+  ["read vector"          "[1 2]"            "(with-in-str \"[1 2]\" (read))"]
+  ["read nil literal"     "nil"              "(with-in-str \"nil\" (read))"]
+  ["read EOF throws"      :throws            "(with-in-str \"\" (read))"]
+  ["read EOF value"       ":done"            "(with-in-str \"\" (read *in* false :done))"]
+  ["read eval data"       "3"                "(with-in-str \"(+ 1 2)\" (eval (read)))"])
+
+(defspec "io / line-seq"
+  ["line-seq"             "[\"a\" \"b\" \"c\"]" "(with-in-str \"a\\nb\\nc\" (vec (line-seq *in*)))"]
+  ["line-seq empty"       "nil"              "(with-in-str \"\" (seq (line-seq *in*)))"]
+  ["line-seq is lazy seq" "true"             "(with-in-str \"a\\nb\" (seq? (line-seq *in*)))"]
+  ["line-seq count"       "3"                "(with-in-str \"1\\n2\\n3\" (count (line-seq *in*)))"])