Refactor: Remove integration tests and organize into modules

This commit refactors the test suite by removing the monolithic
`integration_test.rs` file.
The tests have been categorized and moved into dedicated modules within
the `tests/` directory:

- `tests/parser.rs`: Contains tests for parsing various literal values.
- `tests/destructuring.rs`: Houses tests related to destructuring
  syntax.
- `tests/closures.rs`: Includes tests for closure behavior and related
  optimizations.
- `tests/optimizer.rs`: Contains tests specifically targeting optimizer
  logic and regressions.
- `tests/records.rs`: Holds tests for record syntax and associated
  optimizations.
- `tests/rtl.rs`: Contains tests for runtime library operators and
  functions.
- `tests/pipeline.rs`: Tests for pipeline functionality.
- `tests/macros.rs`: Tests for macro expansion and related issues.
- `tests/error_recovery.rs`: Includes tests for compiler error handling
  and recovery mechanisms.
- `tests/examples.rs`: Verifies the execution of example scripts.

This reorganization improves test discoverability and maintainability.
The `lib.rs` file has also been updated to reflect these changes by
removing the reference to the old `integration_test` module.
The `type_checker.rs` file has had some tests removed, as they are now
covered by the more specific tests in `tests/error_recovery.rs`.

src/ast/compiler/type_checker.rs

@@ -848,39 +848,6 @@ mod tests {
         env.compile(source).into_result().unwrap()
     }
 
-    #[test]
-    fn test_destructuring_scalar_error() {
-        let env = crate::ast::environment::Environment::new();
-        let result = env.compile("(def [x] 5)").into_result();
-        assert!(result.is_err());
-        assert_eq!(
-            result.unwrap_err(),
-            "Statement 'def' cannot be used as an expression.\nCannot destructure type int as a tuple/vector"
-        );
-    }
-
-    #[test]
-    fn test_call_argument_mismatch() {
-        let env = crate::ast::environment::Environment::new();
-        // fn takes 1 arg, called with 0
-        let result = env.compile("(do (def f (fn [x] x)) (f))").into_result();
-        assert!(result.is_err());
-        assert!(
-            result
-                .unwrap_err()
-                .contains("Invalid arguments for function call")
-        );
-    }
-
-    #[test]
-    fn test_destructuring_vector_args() {
-        let env = crate::ast::environment::Environment::new();
-        // ((fn [[x y]] (+ x y)) [10 20]) -> 30
-        let result = env.compile("((fn [[x y]] (+ x y)) [10 20])").into_result();
-        assert!(result.is_ok());
-        assert_eq!(get_ret_type(&result.unwrap()), StaticType::Int);
-    }
-
     fn get_ret_type(node: &TypedNode) -> StaticType {
         if let StaticType::Function(sig) = &node.ty {
             sig.ret.clone()