Implement reader macros (#;, #|...|, #', #name) and #z3 demo

Reader macros in parser.sx spec, Python parser.py, and hand-written sx.js:
- #; datum comment: read and discard next expression
- #|...|  raw string: no escape processing
- #' quote shorthand: (quote expr)
- #name extensible dispatch: registered handler transforms next expression

#z3 reader macro demo (reader_z3.py): translates define-primitive
declarations from primitives.sx into SMT-LIB verification conditions.
Same source, two interpretations — bootstrappers compile to executable
code, #z3 extracts proof obligations.

48 parser tests (SX spec + Python), all passing. Rebootstrapped JS+Python.
Demo page at /plans/reader-macro-demo with side-by-side examples.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

shared/sx/ref/parser.sx

@@ -29,6 +29,12 @@
 ;;   ,expr      → (unquote expr)
 ;;   ,@expr     → (splice-unquote expr)
 ;;
+;; Reader macros:
+;;   #;expr           → datum comment (read and discard expr)
+;;   #|raw chars|     → raw string literal (no escape processing)
+;;   #'expr           → (quote expr)
+;;   #name expr       → extensible dispatch (calls registered handler)
+;;
 ;; Platform interface (each target implements natively):
 ;;   (ident-start? ch)   → boolean
 ;;   (ident-char? ch)    → boolean
@@ -198,6 +204,24 @@
             (read-map-loop)
             result)))
 
+      ;; -- Raw string reader (for #|...|) --
+
+      (define read-raw-string
+        (fn ()
+          (let ((buf ""))
+            (define raw-loop
+              (fn ()
+                (if (>= pos len-src)
+                  (error "Unterminated raw string")
+                  (let ((ch (nth source pos)))
+                    (if (= ch "|")
+                      (do (set! pos (inc pos)) nil)  ;; done
+                      (do (set! buf (str buf ch))
+                          (set! pos (inc pos))
+                          (raw-loop)))))))
+            (raw-loop)
+            buf)))
+
       ;; -- Main expression reader --
 
       (define read-expr
@@ -238,6 +262,40 @@
                             (list (make-symbol "splice-unquote") (read-expr)))
                         (list (make-symbol "unquote") (read-expr))))
 
+                ;; Reader macros: #
+                (= ch "#")
+                  (do (set! pos (inc pos))
+                      (if (>= pos len-src)
+                        (error "Unexpected end of input after #")
+                        (let ((dispatch-ch (nth source pos)))
+                          (cond
+                            ;; #; — datum comment: read and discard next expr
+                            (= dispatch-ch ";")
+                              (do (set! pos (inc pos))
+                                  (read-expr)    ;; read and discard
+                                  (read-expr))   ;; return the NEXT expr
+
+                            ;; #| — raw string
+                            (= dispatch-ch "|")
+                              (do (set! pos (inc pos))
+                                  (read-raw-string))
+
+                            ;; #' — quote shorthand
+                            (= dispatch-ch "'")
+                              (do (set! pos (inc pos))
+                                  (list (make-symbol "quote") (read-expr)))
+
+                            ;; #name — extensible dispatch
+                            (ident-start? dispatch-ch)
+                              (let ((macro-name (read-ident)))
+                                (let ((handler (reader-macro-get macro-name)))
+                                  (if handler
+                                    (handler (read-expr))
+                                    (error (str "Unknown reader macro: #" macro-name)))))
+
+                            :else
+                              (error (str "Unknown reader macro: #" dispatch-ch))))))
+
                 ;; Number (or negative number)
                 (or (and (>= ch "0") (<= ch "9"))
                     (and (= ch "-")
@@ -328,4 +386,8 @@
 ;; String utilities:
 ;;   (escape-string s)   → string with " and \ escaped
 ;;   (sx-expr-source e)  → unwrap SxExpr to its source string
+;;
+;; Reader macro registry:
+;;   (reader-macro-get name)          → handler fn or nil
+;;   (reader-macro-set! name handler) → register a reader macro
 ;; --------------------------------------------------------------------------