Refactor lambda binding and parameter handling

Introduce `BoundKind::Parameter` to represent function parameters.
Modify `Binder` to correctly handle parameters within lambda
definitions, ensuring they are only defined within function scopes.
Update `LambdaCollector` to register the body of lambdas as templates
for global definitions.
Adjust `Dumper` to accurately represent lambda parameters.
Update `Specializer` and `TCO` to handle the new `BoundKind::Parameter`.
Refactor `Call` and `TailCall` to use a single `args` node, often a
tuple.
Adjust type signatures in RTL to use `StaticType::Tuple` for function
parameters.

src/ast/compiler/tco.rs

@@ -16,7 +16,7 @@ impl TCO {
         match node.kind {
             BoundKind::Call { callee, args } => {
                 let new_callee = Box::new(Self::transform(*callee, false));
-                let new_args: Vec<_> = args.into_iter().map(|arg| Self::transform(arg, false)).collect();
+                let new_args = Box::new(Self::transform(*args, false));
                 
                 if is_tail_position {
                     Node {
@@ -75,13 +75,13 @@ impl TCO {
                 }
             },
 
-            BoundKind::Lambda { param_count, upvalues, body } => {
+            BoundKind::Lambda { params, upvalues, body } => {
                 // The body of a lambda is implicitly in tail position when the lambda is called.
                 let new_body = Rc::new(Self::transform((*body).clone(), true));
                 
                 Node {
                     kind: BoundKind::Lambda {
-                        param_count,
+                        params,
                         upvalues,
                         body: new_body,
                     },