graph: normalize link strengths from Jaccard neighborhood similarity

Add jaccard() and jaccard_strengths() to Graph. Jaccard similarity
measures neighborhood overlap between linked nodes — nodes sharing
many neighbors get stronger links, nodes with no shared neighbors
get weak links.

New subcommand: `poc-memory graph normalize-strengths [--apply]`

Scales raw Jaccard (typically 0.0-0.3) to useful range via j*3
clamped to [0.1, 1.0]. Skips implicit temporal edges (strength=1.0).

Applied to 64,969 edges. Distribution is bimodal: large cluster at
0.1-0.2 (weak) and spike at 0.9-1.0 (strong), with smooth gradient
between. Replaces the meaningless 0.3/0.8 split from manual/agent
creation methods.

Co-Authored-By: Kent Overstreet <kent.overstreet@linux.dev>

poc-memory/src/graph.rs

@@ -64,6 +64,43 @@ impl Graph {
             .unwrap_or_default()
     }
 
+    /// Jaccard similarity between two nodes' neighborhoods.
+    /// Measures overlap: |intersection| / |union| of their neighbor sets.
+    pub fn jaccard(&self, a: &str, b: &str) -> f32 {
+        let na = self.neighbor_keys(a);
+        let nb = self.neighbor_keys(b);
+        let intersection = na.intersection(&nb).count();
+        let union = na.union(&nb).count();
+        if union == 0 { 0.0 } else { intersection as f32 / union as f32 }
+    }
+
+    /// Compute Jaccard-based strength for every edge in the graph.
+    /// Returns (source_key, target_key, jaccard_strength) triples.
+    /// Scales raw Jaccard (typically 0.0-0.3) to a useful range.
+    pub fn jaccard_strengths(&self) -> Vec<(String, String, f32)> {
+        let mut result = Vec::new();
+        let mut seen = HashSet::new();
+        for (key, edges) in &self.adj {
+            for edge in edges {
+                // Deduplicate undirected edges
+                let pair = if key < &edge.target {
+                    (key.as_str(), edge.target.as_str())
+                } else {
+                    (edge.target.as_str(), key.as_str())
+                };
+                if !seen.insert((pair.0.to_string(), pair.1.to_string())) {
+                    continue;
+                }
+                let j = self.jaccard(key, &edge.target);
+                // Scale: raw Jaccard 0.05 → 0.15, 0.15 → 0.45, 0.30 → 0.90
+                // Formula: clamp(j * 3, 0.1, 1.0)
+                let strength = (j * 3.0).clamp(0.1, 1.0);
+                result.push((key.clone(), edge.target.clone(), strength));
+            }
+        }
+        result
+    }
+
     pub fn community_count(&self) -> usize {
         let labels: HashSet<_> = self.communities.values().collect();
         labels.len()