fix: address Phase 1c re-review — dry_run guard, clippy, fmt

- Move dry_run check BEFORE import_goal call to prevent database writes
- Remove redundant closures in session row-mapping (clippy)
- Remove unused imports from tests
- Run cargo fmt for consistent formatting

Co-Authored-By: Claude Opus 4.6 <[e-mail]>

src/graph/session.rs

···
                 )?;
 
                 let session: Option<Session> = stmt
-                    .query_row([&session_id_owned], |row| map_session_row(row))
+                    .query_row([&session_id_owned], map_session_row)
                     .optional()?;
 
                 Ok(session)
···
                 )?;
 
                 let session: Option<Session> = stmt
-                    .query_row([&goal_id_owned], |row| map_session_row(row))
+                    .query_row([&goal_id_owned], map_session_row)
                     .optional()?;
 
                 Ok(session)

src/main.rs

···
                             rustagent::graph::interchange::ImportStrategy::Merge
                         };
 
-                        match rustagent::graph::interchange::import_goal(
-                            &graph_store,
-                            &content,
-                            strategy,
-                        )
-                        .await
-                        {
-                            Ok(result) => {
-                                if !dry_run {
+                        if dry_run {
+                            // Parse the TOML and show what would be imported without writing
+                            match toml::from_str::<rustagent::graph::interchange::GoalFile>(
+                                &content,
+                            ) {
+                                Ok(goal_file) => {
+                                    println!("[DRY RUN] Changes that would be applied:");
+                                    println!("  Nodes to process: {}", goal_file.nodes.len());
+                                    println!("  Edges to process: {}", goal_file.edges.len());
+                                    println!("  Import strategy: {:?}", strategy);
+                                }
+                                Err(e) => println!("Failed to parse TOML: {}", e),
+                            }
+                        } else {
+                            match rustagent::graph::interchange::import_goal(
+                                &graph_store,
+                                &content,
+                                strategy,
+                            )
+                            .await
+                            {
+                                Ok(result) => {
                                     println!("  Added nodes: {}", result.added_nodes);
                                     println!("  Added edges: {}", result.added_edges);
                                     println!("  Unchanged: {}", result.unchanged);
···
                                     if !result.skipped_edges.is_empty() {
                                         println!("  Skipped edges: {}", result.skipped_edges.len());
                                     }
-                                } else {
-                                    // Parse the TOML and show what would be imported
-                                    match toml::from_str::<rustagent::graph::interchange::GoalFile>(
-                                        &content,
-                                    ) {
-                                        Ok(goal_file) => {
-                                            println!("[DRY RUN] Changes that would be applied:");
-                                            println!("  Nodes to process: {}", goal_file.nodes.len());
-                                            println!("  Edges to process: {}", goal_file.edges.len());
-                                            println!("  Import strategy: {:?}", strategy);
-                                        }
-                                        Err(e) => println!("Failed to parse TOML: {}", e),
-                                    }
                                 }
+                                Err(e) => println!("Import failed: {}", e),
                             }
-                            Err(e) => println!("Import failed: {}", e),
                         }
                     }
                     Err(e) => println!("Failed to read file: {}", e),
                 },
                 GraphAction::Diff { path } => match std::fs::read_to_string(&path) {
                     Ok(content) => {
-                        match rustagent::graph::interchange::diff_goal(&graph_store, &content)
-                            .await
+                        match rustagent::graph::interchange::diff_goal(&graph_store, &content).await
                         {
                             Ok(result) => {
                                 println!("Diff results for {}:", path);

tests/interchange_test.rs

···
 use anyhow::Result;
 use chrono::Utc;
 use rustagent::graph::interchange::{ImportStrategy, diff_goal, export_goal, import_goal};
-use rustagent::graph::store::{GraphStore, SqliteGraphStore};
+use rustagent::graph::store::GraphStore;
 use rustagent::graph::*;
-use std::collections::HashMap;
-
 mod common;
 use common::*;
 
···
     let toml_str = export_goal(&graph_store, "ra-test", "test-project").await?;
 
     // Modify the TOML to add a new node that doesn't exist and an edge to it
-    let mut toml_content = toml_str.clone();
+    let _toml_content = toml_str.clone();
 
     // Parse and modify
     let mut parsed: toml::Value = toml::from_str(&toml_str)?;
···
     let parsed_export2: toml::Value = toml::from_str(&export2)?;
 
     // Verify nodes are identical between exports (at minimum the counts should match)
-    let nodes1 = parsed_export1["nodes"].as_table().expect("Export should have nodes");
-    let nodes2 = parsed_export2["nodes"].as_table().expect("Import export should have nodes");
+    let nodes1 = parsed_export1["nodes"]
+        .as_table()
+        .expect("Export should have nodes");
+    let nodes2 = parsed_export2["nodes"]
+        .as_table()
+        .expect("Import export should have nodes");
 
     // After round-trip, we should have at least the goal node and ideally all original nodes
     // Verify goal exists in both