When building reference registry for change impact allow lanient mode to allow passing even with validation errrors.

This allows to work with new reqvire code that might fail validaton on previous commits.
Also it allows to have imperfect previous commit but still to do change impact.

Author: Test User

cli/src/cli.rs

@@ -584,7 +584,8 @@ pub fn handle_command(
             })?;
 
             let mut refference_model_manager = ModelManager::new();
-            let _not_interested=refference_model_manager.parse_and_validate(Some(&git_commit), excluded_filename_patterns);
+            // Use lenient mode for reference registry to handle historical commits with validation issues
+            let _not_interested=refference_model_manager.parse_and_validate_with_mode(Some(&git_commit), excluded_filename_patterns, true);
 
             let report=change_impact::compute_change_impact(
                 &model_manager.graph_registry, 

core/src/model.rs

@@ -33,32 +33,47 @@ impl ModelManager {
         git_commit_hash: Option<&str>,
         excluded_filename_patterns: &GlobSet
     ) -> Result<Vec<ReqvireError>, ReqvireError> {
-        debug!("Starting two-pass validation architecture");
+        self.parse_and_validate_with_mode(git_commit_hash, excluded_filename_patterns, false)
+    }
+
+    pub fn parse_and_validate_with_mode(
+        &mut self,
+        git_commit_hash: Option<&str>,
+        excluded_filename_patterns: &GlobSet,
+        lenient: bool
+    ) -> Result<Vec<ReqvireError>, ReqvireError> {
+        debug!("Starting two-pass validation architecture (lenient={})", lenient);
 
         // Pass 1: Element collection with local validation
         let pass1_errors = self.pass1_collect_elements(
             git_commit_hash,
             excluded_filename_patterns
         )?;
 
-        // If Pass 1 has errors, return them as an error
+        // If Pass 1 has errors, return them as an error (unless lenient mode)
         if !pass1_errors.is_empty() {
             debug!("Pass 1 validation failed with {} errors", pass1_errors.len());
-            return Err(ReqvireError::ValidationError(pass1_errors));
+            if !lenient {
+                return Err(ReqvireError::ValidationError(pass1_errors));
+            }
+            debug!("Lenient mode: continuing despite Pass 1 errors");
         }
 
-        debug!("Pass 1 completed successfully, proceeding to Pass 2");
+        debug!("Pass 1 completed, proceeding to Pass 2");
 
         // Pass 2: Graph construction and relation validation
         let pass2_errors = self.pass2_build_relations(excluded_filename_patterns)?;
 
-        // If Pass 2 has errors, return them as an error
+        // If Pass 2 has errors, return them as an error (unless lenient mode)
         if !pass2_errors.is_empty() {
             debug!("Pass 2 validation failed with {} errors", pass2_errors.len());
-            return Err(ReqvireError::ValidationError(pass2_errors));
+            if !lenient {
+                return Err(ReqvireError::ValidationError(pass2_errors));
+            }
+            debug!("Lenient mode: continuing despite Pass 2 errors");
         }
 
-        debug!("Both passes completed successfully");
+        debug!("Validation completed");
         Ok(Vec::new())
     }