feat: Add AST analysis pass for purity and recursion

This commit introduces a new AST analysis pass that identifies function
purity and recursion. This information is then used by the optimizer and
specializer to make more informed decisions, particularly regarding
inlining.

The `Analyzer` struct and its associated `Analysis` struct are
responsible for traversing the AST and collecting this data.

Key changes include:
- A new `analyzer` module is added to `ast::compiler`.
- `Analyzer::analyze` performs a two-pass traversal to collect
  global-to-lambda mappings and then analyze purity and recursion.
- The `Optimizer` and `Specializer` are updated to accept and utilize
  the `Analysis` data.
- Recursion checks in `Optimizer` and `Specializer` are replaced with
  checks against the pre-computed `Analysis.is_recursive` set.
- The `Environment` now stores and passes the `Analysis` results to the
  compiler stages.

src/ast/compiler/specializer.rs

@@ -1,3 +1,4 @@
+use crate::ast::compiler::analyzer::Analysis;
 use crate::ast::compiler::bound_nodes::{Address, BoundKind, BoundNode, TypedNode};
 use crate::ast::nodes::Node;
 use crate::ast::types::{Signature, StaticType, Value};
@@ -22,6 +23,7 @@ pub type MonoCache = HashMap<MonoCacheKey, (Value, StaticType)>;
 
 pub struct Specializer {
     pub cache: Rc<RefCell<MonoCache>>,
+    pub analysis: Analysis,
     registry: Option<Rc<dyn FunctionRegistry>>,
     compiler: Option<CompileFunc>,
     rtl_lookup: Option<RtlLookupFunc>,
@@ -33,9 +35,11 @@ impl Specializer {
         compiler: Option<CompileFunc>,
         rtl_lookup: Option<RtlLookupFunc>,
         cache: Option<Rc<RefCell<MonoCache>>>,
+        analysis: Analysis,
     ) -> Self {
         Self {
             cache: cache.unwrap_or_else(|| Rc::new(RefCell::new(HashMap::new()))),
+            analysis,
             registry,
             compiler,
             rtl_lookup,
@@ -245,6 +249,11 @@ impl Specializer {
 
         // 6. Resolve Function Definition
         if let Some(func_node) = self.registry.as_ref().and_then(|r| r.resolve(address)) {
+            // Check for recursion from pre-pass.
+            if self.analysis.is_recursive.contains(&func_node.identity) {
+                return (new_callee, new_args, original_ty);
+            }
+
             // Check constraints (no closures with state)
             if let BoundKind::Lambda { upvalues, .. } = &func_node.kind {
                 if !upvalues.is_empty() {