refactor: separate parser and compiler AST node structures

Simplified the AST architecture by removing the overly complex Node<K,
  T> structure and replacing it with specialized types for
  each phase:

   - Introduced UntypedNode in nodes.rs for the Parser and Macro system,
     eliminating redundant ty: () initializations.
   - Defined a new generic Node<T> in bound_nodes.rs for all compiler
     stages, where T represents the phase-specific metadata.
   - Updated the Binder to act as the bridge between UntypedNode and
     Node<()>.
   - Simplified type aliases: TypedNode, AnalyzedNode, and ExecNode now
     leverage the streamlined Node<T> structure.
   - Updated Parser, Macros, Type-Checker, Optimizer, and VM to reflect
     the architectural changes.
   - Fixed import chains and resolved needless borrows via clippy.

  This change improves type safety, reduces boilerplate code in the
  parser, and makes the compiler stages more idiomatic and
  readable.

src/ast/compiler/lambda_collector.rs

@@ -1,21 +1,21 @@
-use crate::ast::compiler::bound_nodes::{Address, BoundKind, BoundNode, GlobalIdx};
+use crate::ast::compiler::bound_nodes::{Address, BoundKind, GlobalIdx, Node};
 use std::collections::HashMap;
 use std::rc::Rc;
 
 /// A pass that collects all global function definitions (lambdas) into a registry.
 /// This allows the Specializer to retrieve the original AST of a function for monomorphization.
 pub struct LambdaCollector<'a, T> {
-    registry: &'a mut HashMap<GlobalIdx, Rc<BoundNode<T>>>,
+    registry: &'a mut HashMap<GlobalIdx, Rc<Node<T>>>,
 }
 
 impl<'a, T: Clone> LambdaCollector<'a, T> {
     /// Performs a full traversal of the AST and populates the provided registry.
-    pub fn collect(node: &BoundNode<T>, registry: &'a mut HashMap<GlobalIdx, Rc<BoundNode<T>>>) {
+    pub fn collect(node: &Node<T>, registry: &'a mut HashMap<GlobalIdx, Rc<Node<T>>>) {
         let mut collector = Self { registry };
         collector.visit(node);
     }
 
-    fn visit(&mut self, node: &BoundNode<T>) {
+    fn visit(&mut self, node: &Node<T>) {
         match &node.kind {
             BoundKind::Block { exprs } => {
                 for expr in exprs {