Port ES2022 modules to compat and implement VisitMut for CompatCompiler

This commit ports oxc's ES2022 transformer architecture to SWC's AST and
Visitor API, implementing the VisitMut trait for CompatCompiler to enable
composable transformations.

## Changes

### CompatCompiler
- Implemented VisitMut trait with visitor methods for all relevant AST nodes
- Added support for composable transformations by calling VisitMutHook
  instances
- Transformations execute in order: TypeScript → Plugins → ES2026 → ES2021
  → ES2020 → ES2019 → ES2018 → ES2017 → ES2016 → ES2015 → RegExp

### ES2022 Module
- Ported class_static_block.rs from oxc to SWC
  - Transforms static blocks to private fields with IIFE
  - Implements VisitMutHook for composability
  - Includes comprehensive unit tests
- Created stub implementation for class_properties
  - Full implementation requires ~7000 lines across 13 files
  - Documented implementation plan for incremental porting
- Created ES2022 struct that combines class_static_block and
  class_properties

### TypeScript Support
- Added `enabled()` method to TypeScriptOptions

### Code Quality
- All changes pass `cargo clippy --all --all-targets -- -D warnings`
- Formatted with `cargo fmt --all`

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: kdy1

crates/swc_ecma_compiler/src/compat/es2022/class_properties/mod.rs

@@ -0,0 +1,90 @@
+//! ES2022: Class Properties
+//!
+//! This module transforms class properties and private fields.
+//!
+//! ## Status
+//!
+//! This is currently a stub implementation. The full implementation requires
+//! porting approximately 7000 lines of code from oxc, including:
+//! - class.rs - Core class transformation logic (903 lines)
+//! - private_field.rs - Private field expression transformation (>1000 lines)
+//! - constructor.rs - Constructor injection logic (797 lines)
+//! - super_converter.rs - Super expression transformation (630 lines)
+//! - static_block_and_prop_init.rs - Static block and property transformation
+//!   (550 lines)
+//! - prop_decl.rs - Property declaration transformation (391 lines)
+//! - class_details.rs - Class metadata and private property tracking (283
+//!   lines)
+//! - instance_prop_init.rs - Instance property initializer transformation (231
+//!   lines)
+//! - private_method.rs - Private method transformation (173 lines)
+//! - computed_key.rs - Computed property key handling (164 lines)
+//! - class_bindings.rs - Class name and temp var binding management (146 lines)
+//! - utils.rs - Utility functions (61 lines)
+//!
+//! ## Implementation Plan
+//!
+//! The porting work should be done incrementally:
+//! 1. Port utility modules first (utils.rs, class_bindings.rs,
+//!    class_details.rs)
+//! 2. Then port transformation logic (prop_decl.rs, computed_key.rs, etc.)
+//! 3. Finally port complex transformations (private_field.rs, constructor.rs,
+//!    class.rs)
+//! 4. Integration (mod.rs)
+
+use swc_ecma_hooks::VisitMutHook;
+
+use super::ClassPropertiesOptions;
+use crate::compat::context::TransformCtx;
+
+/// Class properties transformer
+///
+/// This is currently a stub implementation that does nothing.
+/// The full implementation will handle:
+/// - Public class fields
+/// - Private class fields
+/// - Private methods
+/// - Static initialization blocks
+/// - Computed property keys
+pub struct ClassProperties<'ctx> {
+    #[allow(dead_code)]
+    options: ClassPropertiesOptions,
+    #[allow(dead_code)]
+    class_static_block: bool,
+    #[allow(dead_code)]
+    remove_class_fields_without_initializer: bool,
+    #[allow(dead_code)]
+    ctx: &'ctx TransformCtx,
+}
+
+impl<'ctx> ClassProperties<'ctx> {
+    #[allow(dead_code)]
+    pub fn new(
+        options: ClassPropertiesOptions,
+        class_static_block: bool,
+        remove_class_fields_without_initializer: bool,
+        ctx: &'ctx TransformCtx,
+    ) -> Self {
+        Self {
+            options,
+            class_static_block,
+            remove_class_fields_without_initializer,
+            ctx,
+        }
+    }
+}
+
+impl VisitMutHook for ClassProperties<'_> {
+    // This is a stub implementation.
+    // The full implementation would include methods for:
+    // - enter_program / exit_program
+    // - enter_class / exit_class
+    // - enter_class_members
+    // - enter_property_definition / exit_property_definition
+    // - enter_private_property / exit_private_property
+    // - enter_private_method / exit_private_method
+    // - enter_static_block / exit_static_block
+    // - enter_expression / exit_expression
+    // - enter_assign_expr
+    // And many more...
+}