Revert incorrect filter.rs optimization

The previous change to combine filters was actually less efficient than the original.
The original code correctly filters by filename patterns first, then only calls
tags_from_path on files that pass the filename filter. My change was based on
a misunderstanding - there was no duplication of tags_from_path calls.

Keeping the other optimizations:
- Inline hints on filter functions
- String allocation optimizations in identify.rs
- Environment variable clone removal
- Lookup table for is_text_char
- Partitions iterator optimization
- normalize_path optimization

Co-authored-by: j178 <[email protected]>

Author: Copilot

src/cli/run/filter.rs

@@ -155,30 +155,30 @@ impl<'a> FileFilter<'a> {
     /// Filter filenames by file patterns and tags for a specific hook.
     pub(crate) fn for_hook(&self, hook: &Hook) -> Vec<&Path> {
         // Filter by hook `files` and `exclude` patterns.
-        let filename_filter = FilenameFilter::for_hook(hook);
+        let filter = FilenameFilter::for_hook(hook);
+        let filenames = self.filenames.par_iter().filter(|filename| {
+            if let Ok(stripped) = filename.strip_prefix(self.filename_prefix) {
+                filter.filter(stripped)
+            } else {
+                false
+            }
+        });
+
         // Filter by hook `types`, `types_or` and `exclude_types`.
-        let tag_filter = FileTagFilter::for_hook(hook);
-        
-        // Combine both filters in a single pass to avoid calling tags_from_path twice
-        let filenames: Vec<_> = self
-            .filenames
-            .par_iter()
-            .filter_map(|filename| {
-                // First check the filename pattern filter
-                let stripped = filename.strip_prefix(self.filename_prefix).ok()?;
-                if !filename_filter.filter(stripped) {
-                    return None;
-                }
-                
-                // Then check the tag filter
-                match tags_from_path(filename) {
-                    Ok(tags) if tag_filter.filter(&tags) => Some(stripped),
-                    Ok(_) => None,
-                    Err(err) => {
-                        error!(filename = ?filename.display(), error = %err, "Failed to get tags");
-                        None
-                    }
-                }
+        let filter = FileTagFilter::for_hook(hook);
+        let filenames = filenames.filter(|filename| match tags_from_path(filename) {
+            Ok(tags) => filter.filter(&tags),
+            Err(err) => {
+                error!(filename = ?filename.display(), error = %err, "Failed to get tags");
+                false
+            }
+        });
+
+        // Strip the prefix to get relative paths.
+        let filenames: Vec<_> = filenames
+            .map(|p| {
+                p.strip_prefix(self.filename_prefix)
+                    .expect("Failed to strip prefix")
             })
             .collect();
 

src/fs.rs

@@ -126,8 +126,7 @@ pub(crate) fn normalize_path(path: PathBuf) -> PathBuf {
         Err(e) => {
             // Fallback to lossy conversion if not valid UTF-8
             let path = e.into_bytes();
-            let os_str = OsString::from(String::from_utf8_lossy(&path).into_owned());
-            PathBuf::from(os_str)
+            PathBuf::from(OsString::from(String::from_utf8_lossy(&path).as_ref()))
         }
     }
 }