This PR fixes an issue where a @source pointing to a concrete file could result in scanning the entire parent folder instead of only looking for the file we are actually interested in.

When we optimize a @source, we move all the static parts of the pattern to the base. This means that a @source like this:

@source "../../app.config.ts";

Resolves to:

SourceEntry::Pattern { base: "/Users", pattern: "/app.config.ts" }

When walking the base, we would only emit an !app.config.ts rule. This means that everything in the /Users folder is still walked, and the result is then thrown away. If you take a look at the gitignore equivalent (which is what we build behind the scenes), then we would essentially create the following:

!app.config.ts

But if you know how gitignore files work, then you know that this does force app.config.ts to not be ignored, but it doesn't say anything about all the other files/folders.

The fix is to restrict the base so that we ignore everything in the folder, and then explicitly re-include only the pattern we care about. Fixing this would result in the following:

*
!foo.ts

In the reproduction from #20255 this takes the build from appearing to hang (~22s) down to ~20ms on my machine.

There are a few edge cases we have to be careful about:

Multiple patterns for the same base. If we have multiple @source directives for the same folder:

@source "./src/foo.ts";
@source "./src/bar.ts";

Then blindly emitting * for each one would result in this .gitignore equivalent:

*
!foo.ts
*
!bar.ts

Notice that the second * would end up ignoring foo.ts again. To avoid this, we only emit the * rule once per base.

Dynamic parts in intermediate folders. If the pattern still contains a * in one of its folders:

@source "./src/ba*/*.html";

This resolves to:

SourceEntry::Pattern { base: "/src", pattern: "/ba*/*.html" }

If we now inject the * rule for /src, then we would never walk the ba* folders (e.g. bar or baz). To fix this, we add inverse rules for each parent segment of the pattern:

*                     ← ignore everything
!/ba*/                ← except for the `ba*/` folders, so we walk into them
!/ba*/*.html          ← then scan the `*.html` files in them

Bases already covered by a broader source. If the base is already included (or nested) under an unrestricted source (an Auto/External source, or a Pattern containing **), then we leave it alone. Restricting it would incorrectly hide siblings that the broader source is supposed to pick up. For example:

@source "**/*";
@source "./src/components/button.html";

Here the **/* source should keep auto-detecting every file, so we must not restrict src/components just because there's a more specific @source pointing to it.

Source order is preserved throughout, so later @source not … rules can still override an earlier restricted source.

Fixes: #20255

Test plan

1. Added unit tests realted to this sources logic
2. Added integration like tests for the scanner itself
3. All other tests should pass as-s
4. Should work on each OS [ci-all]