fix: filter variant nodes by graph_type in find_cheapest_path

Address Copilot review feedback:
- Add filter_by_graph_type() to constrain Dijkstra start/end nodes
  by the graph_type parameter that was previously ignored
- Clarify find_best_entry fallback doc (intentional for export pipeline)
- Fix test_find_direct_path to not depend on HashMap iteration order

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

Author: GiggleLiu

src/rules/graph.rs

@@ -275,13 +275,36 @@ impl ReductionGraph {
             .collect()
     }
 
+    /// Filter variant nodes by graph type.
+    ///
+    /// If `graph_type` is non-empty, keeps only nodes whose `variant["graph"]`
+    /// matches. Nodes without a `"graph"` key (e.g., QUBO, ILP) pass through
+    /// unconditionally, since graph type is not part of their variant space.
+    fn filter_by_graph_type(&self, nodes: &[NodeIndex], graph_type: &str) -> Vec<NodeIndex> {
+        if graph_type.is_empty() {
+            return nodes.to_vec();
+        }
+        nodes
+            .iter()
+            .copied()
+            .filter(|&idx| {
+                let node = &self.nodes[self.graph[idx]];
+                match node.variant.get("graph") {
+                    Some(g) => g == graph_type,
+                    None => true,
+                }
+            })
+            .collect()
+    }
+
     /// Find the cheapest path using a custom cost function.
     ///
     /// Uses Dijkstra's algorithm on the variant-level graph.
     ///
     /// # Arguments
-    /// - `source`: (problem_name, graph_type) for source — used to look up the variant node
-    /// - `target`: (problem_name, graph_type) for target
+    /// - `source`: `(problem_name, graph_type)` — if `graph_type` is non-empty,
+    ///   only variant nodes with a matching `"graph"` key are used as start points.
+    /// - `target`: `(problem_name, graph_type)` — same filtering for destinations.
     /// - `input_size`: Initial problem size for cost calculations
     /// - `cost_fn`: Custom cost function for path optimization
     ///
@@ -294,17 +317,23 @@ impl ReductionGraph {
         input_size: &ProblemSize,
         cost_fn: &C,
     ) -> Option<ReductionPath> {
-        // Find source nodes matching the name (we try all variant nodes for that name)
-        let src_nodes = self.name_to_nodes.get(source.0)?;
-        let dst_nodes = self.name_to_nodes.get(target.0)?;
+        let all_src = self.name_to_nodes.get(source.0)?;
+        let all_dst = self.name_to_nodes.get(target.0)?;
+
+        let src_nodes = self.filter_by_graph_type(all_src, source.1);
+        let dst_nodes = self.filter_by_graph_type(all_dst, target.1);
+
+        if src_nodes.is_empty() || dst_nodes.is_empty() {
+            return None;
+        }
 
         // Build set of target node indices for quick lookup
         let dst_set: HashSet<NodeIndex> = dst_nodes.iter().copied().collect();
 
         let mut best_path: Option<(f64, ReductionPath)> = None;
 
         // Try from each source node
-        for &src_idx in src_nodes {
+        for &src_idx in &src_nodes {
             let mut costs: HashMap<NodeIndex, f64> = HashMap::new();
             let mut sizes: HashMap<NodeIndex, ProblemSize> = HashMap::new();
             let mut prev: HashMap<NodeIndex, (NodeIndex, petgraph::graph::EdgeIndex)> =
@@ -678,8 +707,11 @@ impl ReductionGraph {
     ///
     /// First tries an exact match on the source variant. If no exact match is found,
     /// falls back to a name-only match (returning the first entry whose source and
-    /// target names match). This allows looking up overhead for specific variants
-    /// (e.g., `K3`) when only the general variant (e.g., `KN`) is registered.
+    /// target names match). This is intentional: specific variants (e.g., `K3`) may
+    /// not have their own `#[reduction]` entry, but the general variant (`KN`) covers
+    /// them with the same overhead polynomial. The fallback is safe because cross-name
+    /// reductions share the same overhead regardless of source variant; it is only
+    /// used by the JSON export pipeline (`export::lookup_overhead`).
     pub fn find_best_entry(
         &self,
         source_name: &str,

src/unit_tests/reduction_graph.rs

@@ -133,7 +133,11 @@ fn test_find_direct_path() {
 
     let paths = graph.find_paths::<MaximumIndependentSet<SimpleGraph, i32>, MinimumVertexCover<SimpleGraph, i32>>();
     assert!(!paths.is_empty());
-    assert_eq!(paths[0].len(), 1);
+    assert!(
+        paths.iter().any(|p| p.len() == 1),
+        "Should contain a direct (1-step) path, got lengths: {:?}",
+        paths.iter().map(|p| p.len()).collect::<Vec<_>>()
+    );
 }
 
 #[test]