feat(phase-c): resolve PhpMixed-conversion phase-b TODOs

Implement the foundational PhpMixed conversion infrastructure
(From<bool|i64|f64|String>, order-sensitive PartialEq matching PHP ===)
and resolve the category-G phase-b TODOs that depend on it:

- Fix VCS driver cache paths that discarded parsed JSON or diverged on
  null caches (svn/forgejo/gitlab/git-bitbucket/github).
- Wire up real conversions previously stubbed or dropped: suggests
  platform config, audit ignore-severities, composer_repository search
  and ProviderInfo, class_loader prefix/classmap merges, locker lock
  diff comparison, advisory JSON serialization, SPDX license fields.
- Make GenericRule take a typed ReasonData; populate RULE_ROOT_REQUIRE
  with the constraint and convert PhpMixed at the call sites.

3 files changed, 20 insertions, 35 deletions

diff --git a/crates/shirabe/src/dependency_resolver/generic_rule.rs b/crates/shirabe/src/dependency_resolver/generic_rule.rs
index eada1c3..9098e93 100644
--- a/crates/shirabe/src/dependency_resolver/generic_rule.rs
+++ b/crates/shirabe/src/dependency_resolver/generic_rule.rs
@@ -2,7 +2,7 @@
 
 use crate::dependency_resolver::{Rule, RuleBase};
 use anyhow::Result;
-use shirabe_php_shim::{PHP_VERSION_ID, PhpMixed, RuntimeException, hash_raw, unpack};
+use shirabe_php_shim::{PHP_VERSION_ID, RuntimeException, hash_raw, unpack};
 
 use super::rule::ReasonData;
 
@@ -13,8 +13,8 @@ pub struct GenericRule {
 }
 
 impl GenericRule {
-    pub fn new(mut literals: Vec<i64>, reason: PhpMixed, reason_data: PhpMixed) -> Self {
-        let inner = RuleBase::new(reason.as_int().unwrap_or(0), ReasonData::from(reason_data));
+    pub fn new(mut literals: Vec<i64>, reason: i64, reason_data: ReasonData) -> Self {
+        let inner = RuleBase::new(reason, reason_data);
         literals.sort();
         Self { inner, literals }
     }
diff --git a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
index 048a5f5..295160c 100644
--- a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
@@ -67,8 +67,8 @@ impl RuleSetGenerator {
 
         Some(GenericRule::new(
             literals,
-            PhpMixed::Int(reason),
-            reason_data,
+            reason,
+            rule::ReasonData::from(reason_data),
         ))
     }
 
@@ -83,7 +83,7 @@ impl RuleSetGenerator {
         reason_data: PhpMixed,
     ) -> GenericRule {
         let literals: Vec<i64> = packages.iter().map(|p| p.get_id()).collect();
-        GenericRule::new(literals, PhpMixed::Int(reason), reason_data)
+        GenericRule::new(literals, reason, rule::ReasonData::from(reason_data))
     }
 
     /// Creates a rule for two conflicting packages.
@@ -368,19 +368,14 @@ impl RuleSetGenerator {
                     self.add_rules_for_package(package.clone(), platform_requirement_filter);
                 }
 
-                let mut reason_data: IndexMap<String, Box<PhpMixed>> = IndexMap::new();
-                reason_data.insert(
-                    "packageName".to_string(),
-                    Box::new(PhpMixed::String(package_name.clone())),
-                );
-                reason_data.insert(
-                    "constraint".to_string(),
-                    Box::new(PhpMixed::Null), // reasonData: $constraint (ConstraintInterface)
-                );
-                let rule = self.create_install_one_of_rule(
-                    &packages,
+                let literals: Vec<i64> = packages.iter().map(|p| p.get_id()).collect();
+                let rule = GenericRule::new(
+                    literals,
                     rule::RULE_ROOT_REQUIRE,
-                    PhpMixed::Array(reason_data),
+                    rule::ReasonData::RootRequire {
+                        package_name: package_name.clone(),
+                        constraint: constraint.clone(),
+                    },
                 );
                 self.add_rule(RuleSet::TYPE_REQUEST, Some(Rule::Generic(rule)));
             }
diff --git a/crates/shirabe/src/dependency_resolver/solver.rs b/crates/shirabe/src/dependency_resolver/solver.rs
index def586a..28e1e7f 100644
--- a/crates/shirabe/src/dependency_resolver/solver.rs
+++ b/crates/shirabe/src/dependency_resolver/solver.rs
@@ -211,23 +211,13 @@ impl Solver {
                 .is_empty()
             {
                 let mut problem = Problem::new();
-                let mut reason_data: IndexMap<String, PhpMixed> = IndexMap::new();
-                reason_data.insert(
-                    "packageName".to_string(),
-                    PhpMixed::String(package_name.clone()),
-                );
-                // TODO(phase-b): store the constraint inside reason_data; PhpMixed needs to
-                // accept a `dyn ConstraintInterface` wrapper.
-                reason_data.insert("constraint".to_string(), PhpMixed::Null);
                 problem.add_rule(Rc::new(RefCell::new(Rule::Generic(GenericRule::new(
                     Vec::new(),
-                    PhpMixed::Int(rule::RULE_ROOT_REQUIRE),
-                    PhpMixed::Array(
-                        reason_data
-                            .into_iter()
-                            .map(|(k, v)| (k, Box::new(v)))
-                            .collect(),
-                    ),
+                    rule::RULE_ROOT_REQUIRE,
+                    rule::ReasonData::RootRequire {
+                        package_name: package_name.clone(),
+                        constraint: active_constraint.clone(),
+                    },
                 )))));
                 self.problems.push(problem);
             }
@@ -620,8 +610,8 @@ impl Solver {
         array_unshift::<i64>(&mut other_learned_literals, learned_literal);
         let new_rule = GenericRule::new(
             other_learned_literals,
-            PhpMixed::Int(rule::RULE_LEARNED),
-            PhpMixed::Int(why),
+            rule::RULE_LEARNED,
+            rule::ReasonData::Int(why),
         );
 
         Ok((learned_literal, rule_level, new_rule, why))