refactor(interpreter): Step 5 - Extract builtins module

- Move execute_builtin_box_method() to expressions/builtins.rs (88 lines)
- Move execute_builtin_birth_method() to expressions/builtins.rs (74 lines)
- Complete expressions module refactoring (5/5 steps)
- Remove orphaned doc comment that prevented compilation
- Total extracted: ~380 lines from mod.rs to 4 specialized modules
- Improved maintainability with single responsibility principle

src/interpreter/expressions/access.rs

@@ -2,4 +2,145 @@
  * Field access operations
  */
 
-use super::*;
+use super::*;
+use crate::ast::ASTNode;
+use crate::box_trait::{NyashBox, SharedNyashBox};
+use crate::boxes::FutureBox;
+use crate::{InstanceBox};
+use crate::interpreter::core::{NyashInterpreter, RuntimeError};
+use std::sync::Arc;
+
+impl NyashInterpreter {
+    /// フィールドアクセスを実行 - Field access processing with weak reference support
+    pub(super) fn execute_field_access(&mut self, object: &ASTNode, field: &str) 
+        -> Result<SharedNyashBox, RuntimeError> {
+        
+        // 🔥 Static Boxアクセスチェック
+        if let ASTNode::Variable { name, .. } = object {
+            // Static boxの可能性をチェック
+            if self.is_static_box(name) {
+                let static_result = self.execute_static_field_access(name, field)?;
+                return Ok(Arc::from(static_result));
+            }
+        }
+        
+        
+        // オブジェクトを評価（通常のフィールドアクセス）  
+        let obj_value = self.execute_expression(object);
+        
+        let obj_value = obj_value?;
+        
+        // InstanceBoxにキャスト
+        if let Some(instance) = obj_value.as_any().downcast_ref::<InstanceBox>() {
+            // 🔥 Usage prohibition guard - check if instance is finalized
+            if instance.is_finalized() {
+                return Err(RuntimeError::InvalidOperation {
+                    message: "Instance was finalized; further use is prohibited".to_string(),
+                });
+            }
+            
+            // フィールドの値を取得
+            let field_value = instance.get_field(field)
+                .ok_or(RuntimeError::InvalidOperation {
+                    message: format!("Field '{}' not found in {}", field, instance.class_name),
+                })?;
+            
+            eprintln!("✅ FIELD ACCESS: Returning shared reference id={}", field_value.box_id());
+            
+            // 🔗 Weak Reference Check: Use unified accessor for weak fields
+            let box_decls = self.shared.box_declarations.read().unwrap();
+            if let Some(box_decl) = box_decls.get(&instance.class_name) {
+                if box_decl.weak_fields.contains(&field.to_string()) {
+                    eprintln!("🔗 DEBUG: Accessing weak field '{}' in class '{}'", field, instance.class_name);
+                    
+                    // 🎯 PHASE 2: Use unified accessor for auto-nil weak reference handling
+                    if let Some(weak_value) = instance.get_weak_field(field, self) { // Pass self
+                        match &weak_value {
+                            crate::value::NyashValue::Null => {
+                                eprintln!("🔗 DEBUG: Weak field '{}' is null (reference dropped)", field);
+                                // Return null box for compatibility
+                                return Ok(Arc::new(crate::boxes::null_box::NullBox::new()));
+                            }
+                            _ => {
+                                eprintln!("🔗 DEBUG: Weak field '{}' still has valid reference", field);
+                                // Convert back to Box<dyn NyashBox> for now
+                                if let Ok(box_value) = weak_value.to_box() {
+                                    if let Ok(inner_box) = box_value.try_lock() {
+                                        return Ok(Arc::from(inner_box.clone_box()));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // If weak field access failed, fall through to normal access
+                }
+            }
+            
+            // Return the shared Arc reference directly
+            Ok(field_value)
+        } else {
+            Err(RuntimeError::TypeError {
+                message: format!("Cannot access field '{}' on non-instance type. Type: {}", field, obj_value.type_name()),
+            })
+        }
+    }
+    
+    /// 🔥 Static Box名前空間のフィールドアクセス
+    fn execute_static_field_access(&mut self, static_box_name: &str, field: &str) 
+        -> Result<Box<dyn NyashBox>, RuntimeError> {
+        // 1. Static Boxの初期化を確実に実行
+        self.ensure_static_box_initialized(static_box_name)?;
+        
+        // 2. GlobalBox.statics.{static_box_name} からインスタンスを取得
+        let global_box = self.shared.global_box.lock()
+            .map_err(|_| RuntimeError::RuntimeFailure {
+                message: "Failed to acquire global box lock".to_string()
+            })?;
+            
+        let statics_box = global_box.get_field("statics")
+            .ok_or(RuntimeError::RuntimeFailure {
+                message: "statics namespace not found in GlobalBox".to_string()
+            })?;
+            
+        let statics_instance = statics_box.as_any()
+            .downcast_ref::<InstanceBox>()
+            .ok_or(RuntimeError::TypeError {
+                message: "statics field is not an InstanceBox".to_string()
+            })?;
+            
+        let static_box_instance = statics_instance.get_field(static_box_name)
+            .ok_or(RuntimeError::RuntimeFailure {
+                message: format!("Static box '{}' instance not found in statics namespace", static_box_name)
+            })?;
+            
+        let instance = static_box_instance.as_any()
+            .downcast_ref::<InstanceBox>()
+            .ok_or(RuntimeError::TypeError {
+                message: format!("Static box '{}' is not an InstanceBox", static_box_name)
+            })?;
+        
+        // 3. フィールドアクセス
+        let shared_field = instance.get_field(field)
+            .ok_or(RuntimeError::InvalidOperation {
+                message: format!("Field '{}' not found in static box '{}'", field, static_box_name),
+            })?;
+        
+        // Convert Arc to Box for compatibility
+        Ok((*shared_field).clone_box())
+    }
+    
+    
+    /// await式を実行 - Execute await expression
+    pub(super) fn execute_await(&mut self, expression: &ASTNode) -> Result<Box<dyn NyashBox>, RuntimeError> {
+        let value = self.execute_expression(expression)?;
+        
+        // FutureBoxなら待機して結果を取得
+        if let Some(future) = value.as_any().downcast_ref::<FutureBox>() {
+            future.wait_and_get()
+                .map_err(|msg| RuntimeError::InvalidOperation { message: msg })
+        } else {
+            // FutureBoxでなければそのまま返す
+            Ok(value)
+        }
+    }
+}