fix: Restore temp table persistence in --execute-statement mode

Fixes critical regression where temp tables created with SELECT INTO
were not persisting between statements in dependency-aware execution
(\sx mode in nvim plugin).

## Problem

After the execution mode unification refactor (commit e3ec558), temp
tables stopped working in --execute-statement mode. When executing:

```sql
SELECT * FROM web_cte INTO #temp;
GO

SELECT * FROM #temp;
GO
```

Statement #2 would return DUMMY table instead of the temp table data.

## Root Cause

The StatementExecutor.execute() method was removing the INTO clause
during preprocessing (line 175) before execution, so the QueryEngine
never knew to store the result as a temp table. The INTO clause was
being stripped by IntoClauseRemover but the result was never captured.

## Solution

Modified StatementExecutor.execute() to:
1. Capture INTO table name BEFORE preprocessing removes it (Step 0)
2. Execute the query normally
3. If INTO clause was present, materialize the result and store it
   in the ExecutionContext's temp_tables registry (Step 4)

This ensures temp tables persist within a single --execute-statement
invocation across multiple dependent statements.

## Changes

**src/execution/statement_executor.rs:**
- Added Step 0: Capture into_table_name before preprocessing
- Added Step 4: Materialize and store result if INTO clause was present
- Uses QueryEngine.materialize_view() to convert DataView to DataTable
- Stores in context.temp_tables for subsequent statement access

## Testing

All 10 statement_executor tests pass.

User scenario now works:
1. \sx on statement #1: Creates #temp with 72,888 rows ✓
2. \sx on statement #2: Queries #temp, returns actual data ✓

Fixes regression introduced in execution mode unification.

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

Co-Authored-By: Claude <noreply@anthropic.com>

Author: TimelordUK

src/execution/statement_executor.rs

@@ -114,6 +114,9 @@ impl StatementExecutor {
         let total_start = Instant::now();
         let mut stats = ExecutionStats::new();
 
+        // Step 0: Check if this statement has an INTO clause (before preprocessing removes it!)
+        let into_table_name = stmt.into_table.as_ref().map(|it| it.name.clone());
+
         // Step 1: Determine source table
         let source_table = if let Some(ref from_table) = stmt.from_table {
             context.resolve_table(from_table)
@@ -133,7 +136,18 @@ impl StatementExecutor {
         let result_view = self.execute_ast(transformed_stmt.clone(), source_table, context)?;
         stats.execution_time_ms = exec_start.elapsed().as_secs_f64() * 1000.0;
 
-        // Step 4: Collect statistics
+        // Step 4: If this was a SELECT INTO statement, store the result as a temp table
+        if let Some(table_name) = into_table_name {
+            // Materialize the view into a DataTable using QueryEngine's method
+            let engine = QueryEngine::with_case_insensitive(self.config.case_insensitive);
+            let temp_table = engine.materialize_view(result_view.clone())?;
+
+            // Store in temp table registry
+            context.store_temp_table(table_name.clone(), Arc::new(temp_table))?;
+            tracing::debug!("Stored temp table: {}", table_name);
+        }
+
+        // Step 5: Collect statistics
         stats.total_time_ms = total_start.elapsed().as_secs_f64() * 1000.0;
         stats.row_count = result_view.row_count();
         stats.column_count = result_view.column_count();