Address Copilot review on pathutil filters

- FilterPaths/ListEntries: feed slash-separated paths into runFilters via
  filepath.ToSlash so BaseFilter/ExtensionFilter/ComponentFilter work on
  Windows. Returned paths stay OS-native.
- BySortablePathComponents.Less: tie-break on AbsPth then Pth after the
  base-name comparison so same-depth same-base entries sort
  deterministically (sort.Sort is not stable).
- ComponentWithExtensionFilter: case-insensitive (strings.EqualFold) to
  match BaseFilter/ExtensionFilter.
- sortable_path_test: POSIX-only assertions (filepath.Abs differs on
  Windows). Skip on GOOS=windows rather than try to make path-mechanics
  tests platform-neutral; CI already runs Linux/macOS only.

RegexpFilter.MustCompile is left as-is: callers pass literal patterns at
construction time, so an invalid pattern surfaces in their own unit
tests, not in production.

Author: Badlazzor

pathutil/path_filter.go

@@ -79,11 +79,12 @@ func ComponentFilter(component string, allowed bool) FilterFunc {
 }
 
 // ComponentWithExtensionFilter matches entries whose path has at least one
-// component with the given extension.
+// component with the given extension (case-insensitive, leading dot
+// included, e.g. ".xcodeproj").
 func ComponentWithExtensionFilter(ext string, allowed bool) FilterFunc {
 	return func(pth string, _ fs.DirEntry) (bool, error) {
 		found := slices.ContainsFunc(strings.Split(pth, "/"), func(c string) bool {
-			return path.Ext(c) == ext
+			return strings.EqualFold(path.Ext(c), ext)
 		})
 		return allowed == found, nil
 	}

pathutil/path_filter_compat.go

@@ -31,7 +31,7 @@ func FilterPaths(paths []string, filters ...FilterFunc) ([]string, error) {
 			return nil, err
 		}
 
-		keep, err := runFilters(pth, d, filters)
+		keep, err := runFilters(filepath.ToSlash(pth), d, filters)
 		if err != nil {
 			return nil, err
 		}
@@ -61,7 +61,7 @@ func ListEntries(dir string, filters ...FilterFunc) ([]string, error) {
 	var filtered []string
 	for _, entry := range entries {
 		pth := filepath.Join(absDir, entry.Name())
-		keep, err := runFilters(pth, entry, filters)
+		keep, err := runFilters(filepath.ToSlash(pth), entry, filters)
 		if err != nil {
 			return nil, err
 		}

pathutil/sortable_path.go

@@ -39,7 +39,9 @@ func NewSortablePath(pth string) (SortablePath, error) {
 }
 
 // BySortablePathComponents sorts SortablePath values by component depth
-// (shallowest first), breaking ties alphabetically on the base name.
+// (shallowest first), breaking ties alphabetically on the base name and
+// falling back to the absolute and original paths to keep the order
+// deterministic when same-depth same-base entries exist.
 type BySortablePathComponents []SortablePath
 
 func (s BySortablePathComponents) Len() int      { return len(s) }
@@ -48,7 +50,14 @@ func (s BySortablePathComponents) Less(i, j int) bool {
 	if len(s[i].Components) != len(s[j].Components) {
 		return len(s[i].Components) < len(s[j].Components)
 	}
-	return filepath.Base(s[i].AbsPth) < filepath.Base(s[j].AbsPth)
+	baseI, baseJ := filepath.Base(s[i].AbsPth), filepath.Base(s[j].AbsPth)
+	if baseI != baseJ {
+		return baseI < baseJ
+	}
+	if s[i].AbsPth != s[j].AbsPth {
+		return s[i].AbsPth < s[j].AbsPth
+	}
+	return s[i].Pth < s[j].Pth
 }
 
 // SortPathsByComponents returns paths sorted by directory depth.

pathutil/sortable_path_test.go

@@ -3,12 +3,26 @@ package pathutil
 import (
 	"os"
 	"path/filepath"
+	"runtime"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 )
 
+// These tests assume POSIX-style absolute paths (no drive letter, "/" as
+// separator). filepath.Abs and component splitting differ on Windows, so
+// the bare-string assertions would not hold there. CI for go-utils runs on
+// Linux and macOS only; skip on Windows to keep the test honest.
+func skipOnWindows(t *testing.T) {
+	t.Helper()
+	if runtime.GOOS == "windows" {
+		t.Skip("POSIX-only: filepath.Abs and component split differ on Windows")
+	}
+}
+
 func TestNewSortablePath(t *testing.T) {
+	skipOnWindows(t)
+
 	sp, err := NewSortablePath("/a/b/c.txt")
 	require.NoError(t, err)
 	require.Equal(t, "/a/b/c.txt", sp.Pth)
@@ -17,6 +31,8 @@ func TestNewSortablePath(t *testing.T) {
 }
 
 func TestSortPathsByComponents(t *testing.T) {
+	skipOnWindows(t)
+
 	input := []string{
 		"/a/b/c/deep.txt",
 		"/x.txt",
@@ -35,13 +51,27 @@ func TestSortPathsByComponents(t *testing.T) {
 }
 
 func TestSortPathsByComponents_tiebreakAlphabetic(t *testing.T) {
+	skipOnWindows(t)
+
 	input := []string{"/a/zeta.txt", "/a/alpha.txt", "/a/mu.txt"}
 
 	got, err := SortPathsByComponents(input)
 	require.NoError(t, err)
 	require.Equal(t, []string{"/a/alpha.txt", "/a/mu.txt", "/a/zeta.txt"}, got)
 }
 
+func TestSortPathsByComponents_tiebreakSameBaseDifferentDir(t *testing.T) {
+	skipOnWindows(t)
+
+	// Same depth, same base name — without the AbsPth tie-breaker the
+	// resulting order would be nondeterministic (sort.Sort is not stable).
+	input := []string{"/b/x.txt", "/a/x.txt"}
+
+	got, err := SortPathsByComponents(input)
+	require.NoError(t, err)
+	require.Equal(t, []string{"/a/x.txt", "/b/x.txt"}, got)
+}
+
 func TestListPathInDirSortedByComponents(t *testing.T) {
 	root := t.TempDir()
 	mustWrite(t, filepath.Join(root, "top.txt"), "x")