Fix Maven dependency coordinate property interpolation

Interpolate groupId and artifactId in addition to version in the declare() function. This ensures that property coordinates like ${project.groupId} are properly resolved before being passed to enqueue() and managed_version(), allowing artifacts with property-based coordinates to match path-derived crawl names and be correctly included in project-mode scans.

Author: cursoragent

crates/socket-patch-core/src/crawlers/maven_scope.rs

@@ -273,31 +273,37 @@ impl Walk<'_> {
     /// Queue `decl` read in `chain`'s context. A transitive edge also takes
     /// any version the reactor's management assigns its artifact.
     fn declare(&mut self, decl: &PomDecl, chain: &Chain, direct: bool) {
+        let Some(group) = interpolate(&decl.group, chain) else {
+            return;
+        };
+        let Some(artifact) = interpolate(&decl.artifact, chain) else {
+            return;
+        };
         if !direct {
             let reactor = std::mem::take(&mut self.reactor_chains);
             for (i, rc) in reactor.iter().enumerate() {
-                let key = (i, decl.group.clone(), decl.artifact.clone());
+                let key = (i, group.clone(), artifact.clone());
                 let managed = match self.reactor_managed.get(&key) {
                     Some(found) => found.clone(),
                     None => {
-                        let found = self.managed_version(rc, &decl.group, &decl.artifact, 0);
+                        let found = self.managed_version(rc, &group, &artifact, 0);
                         self.reactor_managed.insert(key, found.clone());
                         found
                     }
                 };
                 if let Some(version) = managed {
-                    self.enqueue(&decl.group, &decl.artifact, version);
+                    self.enqueue(&group, &artifact, version);
                 }
             }
             self.reactor_chains = reactor;
         }
         let version = match &decl.version {
             Some(raw) => Some(interpolate(raw, chain)),
             None => self
-                .managed_version(chain, &decl.group, &decl.artifact, 0)
+                .managed_version(chain, &group, &artifact, 0)
                 .or(Some(None)),
         };
-        self.enqueue(&decl.group, &decl.artifact, version.flatten());
+        self.enqueue(&group, &artifact, version.flatten());
     }
 
     /// The version `chain` manages `g:a` at: its parent chain's management,

crates/socket-patch-core/src/patch/redirect/upstream/mod.rs

@@ -917,7 +917,10 @@ mod tests {
     fn bun_lock_remedies_name_the_forced_reinstall() {
         for file in ["bun.lockb", "bun.lock", "packages/app/bun.lockb"] {
             let remedy = checkout_remedy(&[file.to_string()]);
-            assert!(remedy.contains(&format!("`git checkout -- {file}`")), "{remedy}");
+            assert!(
+                remedy.contains(&format!("`git checkout -- {file}`")),
+                "{remedy}"
+            );
             assert!(remedy.ends_with(
                 ", then run `bun install --force` (a plain `bun install` keeps the patched copy)"
             ), "{remedy}");