docs(checker): reframe MAX_EXPR_DEPTH as a stack-recursion bound (closes #14) (#36)

The #14 investigation conclusively showed check_expr / is_assignable_from
are linear in AST size on Linux and on the Windows CI leg, so the depth
guard is NOT a defence against runaway allocation. Reword its doc-comment
and the related inline comments to state what it actually does -- bound
stack recursion -- and point at the investigation record. No behaviour
change. Residual subtleties (recursive AST Drop; owner-dependent exact
repro + Windows ETW deep-dive; re-tuning the 256 value) are carved into
separate tracking issues so #14 can close on its answered question.

Closes #14

https://claude.ai/code/session_016X6sPXqrpMxHRMuy46BjeS

Co-authored-by: Claude <noreply@anthropic.com>

Author: hyperpolymath

crates/my-lang/src/checker.rs

@@ -113,10 +113,16 @@ pub enum CheckError {
 /// emitting [`CheckError::ExpressionTooDeep`] and bailing out of the
 /// subexpression.
 ///
-/// This is a defence against pathological inputs (deeply chained
-/// `str_concat`/`format`, parser-generated unbalanced trees) that could
-/// otherwise drive the checker into runaway memory allocation. See
-/// hyperpolymath/my-lang#1.
+/// This bounds **stack recursion**, not heap growth. The #14 investigation
+/// (see `docs/wiki/internals/checker-allocation-investigation.md`) measured
+/// `check_expr` / `is_assignable_from` to be *linear* in AST size on Linux
+/// and on a Windows CI leg — there is no super-linear allocation for the
+/// guard to defend against. What deep nesting *does* threaten is the
+/// recursive descent through `check_expr` (and the recursive `Drop` of the
+/// resulting AST). The original #1 OOM was shown not to be checker
+/// algorithmic complexity; this limit therefore exists to keep recursion
+/// depth finite, and rejecting deep-but-legal programs at 256 is its cost,
+/// not a memory safeguard. Re-tuning the value is tracked separately.
 pub const MAX_EXPR_DEPTH: usize = 256;
 
 pub type CheckResult<T> = Result<T, CheckError>;
@@ -128,8 +134,8 @@ pub struct Checker {
     errors: Vec<CheckError>,
     /// Current function's return type (for checking return statements)
     current_return_type: Option<Ty>,
-    /// Current expression-recursion depth (guards against OOM on pathological
-    /// nesting, see [`MAX_EXPR_DEPTH`]).
+    /// Current expression-recursion depth (bounds stack recursion on
+    /// pathological nesting, see [`MAX_EXPR_DEPTH`]).
     expr_depth: usize,
     /// Set once an [`CheckError::ExpressionTooDeep`] has been reported, to
     /// avoid spamming a duplicate error for every parent expression on the
@@ -841,8 +847,9 @@ impl Checker {
 
     fn check_expr_guarded(&mut self, expr: &Expr) -> Ty {
         // Depth guard: stops pathological inputs (e.g. deeply chained
-        // str_concat/format) from driving the checker into runaway memory
-        // allocation or stack overflow. Reports a single ExpressionTooDeep
+        // str_concat/format) from driving the checker into a stack overflow
+        // via unbounded recursion (allocation is linear — see #14).
+        // Reports a single ExpressionTooDeep
         // error for the whole offending subtree and returns Ty::Error so the
         // surrounding code keeps type-checking in error-recovery mode.
         if self.expr_depth >= MAX_EXPR_DEPTH {