feat(differ): add SymbolDiff types and AstDiffer for structural diffs

Introduces ChangeDetail enum (15 variants) and AstDiffer that compares
old/new tree-sitter nodes for parameter, return type, visibility, async,
and body changes. Struct/enum diffing stubbed for future implementation.
Body comparison uses whitespace-stripped character streams.

Author: Sephyi

src/domain/diff.rs

@@ -0,0 +1,119 @@
+// SPDX-FileCopyrightText: 2026 Sephyi <me@sephy.io>
+//
+// SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Commercial
+
+use std::path::PathBuf;
+
+/// Structured description of how a symbol changed between old and new versions.
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct SymbolDiff {
+    pub name: String,
+    pub file: PathBuf,
+    pub line: usize,
+    pub parent_scope: Option<String>,
+    pub changes: Vec<ChangeDetail>,
+}
+
+/// A single semantic change within a symbol.
+#[derive(Debug, Clone, PartialEq)]
+#[allow(dead_code)]
+pub enum ChangeDetail {
+    ParamAdded(String),
+    ParamRemoved(String),
+    ParamTypeChanged {
+        name: String,
+        old_type: String,
+        new_type: String,
+    },
+    ReturnTypeChanged {
+        old: String,
+        new: String,
+    },
+    VisibilityChanged {
+        old: Option<String>,
+        new: Option<String>,
+    },
+    AttributeAdded(String),
+    AttributeRemoved(String),
+    AsyncChanged(bool),
+    GenericChanged {
+        old: String,
+        new: String,
+    },
+    BodyModified {
+        additions: usize,
+        deletions: usize,
+    },
+    BodyUnchanged,
+    FieldAdded(String),
+    FieldRemoved(String),
+    FieldTypeChanged {
+        name: String,
+        old_type: String,
+        new_type: String,
+    },
+}
+
+#[allow(dead_code)]
+impl SymbolDiff {
+    /// Format as a concise one-line description for the LLM prompt.
+    #[must_use]
+    pub fn format_oneline(&self) -> String {
+        let scope = self
+            .parent_scope
+            .as_ref()
+            .map(|s| format!("{s}::"))
+            .unwrap_or_default();
+        let changes: Vec<String> = self.changes.iter().map(|c| c.format_short()).collect();
+        format!("  {scope}{}(): {}", self.name, changes.join(", "))
+    }
+}
+
+#[allow(dead_code)]
+impl ChangeDetail {
+    #[must_use]
+    pub fn format_short(&self) -> String {
+        match self {
+            Self::ParamAdded(p) => format!("+param {p}"),
+            Self::ParamRemoved(p) => format!("-param {p}"),
+            Self::ParamTypeChanged {
+                name,
+                old_type,
+                new_type,
+            } => {
+                format!("param {name} {old_type} \u{2192} {new_type}")
+            }
+            Self::ReturnTypeChanged { old, new } => format!("return {old} \u{2192} {new}"),
+            Self::VisibilityChanged { old, new } => format!(
+                "visibility {} \u{2192} {}",
+                old.as_deref().unwrap_or("private"),
+                new.as_deref().unwrap_or("private")
+            ),
+            Self::AttributeAdded(a) => format!("+attr {a}"),
+            Self::AttributeRemoved(a) => format!("-attr {a}"),
+            Self::AsyncChanged(is_async) => {
+                if *is_async {
+                    "+async".into()
+                } else {
+                    "-async".into()
+                }
+            }
+            Self::GenericChanged { old, new } => format!("generics {old} \u{2192} {new}"),
+            Self::BodyModified {
+                additions,
+                deletions,
+            } => format!("body modified (+{additions} -{deletions})"),
+            Self::BodyUnchanged => "signature only".into(),
+            Self::FieldAdded(f) => format!("+field {f}"),
+            Self::FieldRemoved(f) => format!("-field {f}"),
+            Self::FieldTypeChanged {
+                name,
+                old_type,
+                new_type,
+            } => {
+                format!("field {name} {old_type} \u{2192} {new_type}")
+            }
+        }
+    }
+}

src/domain/mod.rs

@@ -5,6 +5,7 @@
 mod change;
 mod commit;
 mod context;
+pub mod diff;
 mod symbol;
 
 pub use change::*;