`projectile-purge-file-from-cache' writes the updated file list to
disk under persistent caching; the directory variant only mutated
the in-memory hash, so the purged subtree would reappear on the
next Emacs session.  Mirror the persistence step here.

Without this, `projectile-files-cache-expire' combined with persistent
caching ended up re-reading the cache file from disk on every call to
`projectile-project-files' and never reindexing: the TTL check at the
top of `projectile-project-files' evicts the in-memory entry whenever
its cache time is missing, and `projectile-load-project-cache' was
populating only `projectile-projects-cache' on disk loads.  Use the
cache file's mtime as the recorded time, so the TTL check sees a real
age and reindexing happens when (and only when) the data is actually
stale.

`projectile-get-ext-command' had no direct test coverage, so the
non-git VCS branches (hg/svn/bzr/darcs/fossil/pijul/sapling/jj) were
relying on indirect coverage that didn't actually exercise the
dispatch. Add a `describe' block that pins each branch.

Also extend the `projectile-dir-files-alien' tests with two cases
that were previously uncovered: the fd path for git (verifying we
don't also call `projectile-git-deleted-files') and the no-VCS
fallback (verifying the generic command is used).

Cover the new internal helpers (`projectile--list->set',
`projectile--ignored-file-fast-p', `projectile--ignored-directory-
fast-p') and add end-to-end tests for the previously uncovered
behaviour:

* `projectile-index-directory' honors dirconfig glob ignore patterns
  at every directory level - previously only the alien-mode dirconfig
  warning had any test coverage for this.
* Ensure (`!') entries in `.projectile' override an ignore pattern.
* `projectile-remove-ignored' drops basename matches, treats `*'-
  prefixed ignored-dir entries as any-segment matches, and treats
  plain entries as path-prefix matches.

`+' keep entries had no end-to-end test coverage. Add tests that verify:

* Multiple `+' keep entries trigger a single batched call to the
  external command, with the kept paths passed as the new pathspecs
  argument.
* The single-keep-dir case keeps going through `projectile-dir-files'
  for each subdirectory (no behavioural change there).
* `projectile--restricted-sub-projects-files' returns all submodule
  files when no subdirs are supplied, drops files outside the supplied
  subdirs when they are, and normalises subdirs without a trailing
  slash.

Also add a focused test for the new `pathspecs' argument of
`projectile-files-via-ext-command'.

The hybrid path through `projectile-dir-files` had zero direct
coverage. Add tests that verify it applies
`projectile-globally-ignored-file-suffixes` and dirconfig ignore
patterns on top of the alien result, and that the resolved VCS is
threaded through to `projectile-dir-files-alien` exactly once.

Also adds a focused test for `projectile-dir-files-alien` honoring an
explicitly supplied VCS argument without re-running
`projectile-project-vcs`.

The existing projectile-invalidate-cache always tries to also clear
the per-project files cache, which means it either prompts for a
project (with prefix arg) or only operates when you're already in a
project.  Users who just created a marker file in a directory that
Projectile previously considered rootless ended up picking an
unrelated project from the prompt just to get the root cache
flushed.

projectile-discard-root-cache is a focused alternative that empties
projectile-project-root-cache only.  Wired into the menu next to the
existing 'Invalidate cache' entry; deliberately not bound on the
prefix map since the keymap is already dense.

- projectile-root-marked: default and custom dirconfig file, miss case
- projectile-root-local: returns the buffer-local var, ignores DIR
- projectile-root-bottom-up: matches a regular-file marker (e.g. git
  worktree's .git file)
- projectile-ensure-project: all three projectile-require-project-root
  branches (nil / t / 'prompt) plus the dir-non-nil pass-through
- projectile-acquire-root: the success path and the no-root delegation
- projectile-project-root: tramp-archive path unwrap, verified by
  observing the directory handed to a stub root function (a
  defvar-backed variable is needed because byte-compiled lexical
  closures don't propagate setq through cl-letf-mocked dispatch)

Previously a root function returning nil stored nil in the cache,
which is indistinguishable from a missing entry, so on the next call
the function was re-run.  When a project's root is found by the third
function in projectile-project-root-functions, the first two
re-walked the tree on every call - and projectile-project-root is hot
in mode-line / company / spaceline updates.

Store the symbol 'none for unsuccessful entries and treat it as a
cache hit on lookup.  The overall-failure marker already used 'none
in a separate slot, so this just extends the same convention to the
per-function entries.

projectile-root-local reads the buffer-local projectile-project-root
variable rather than inspecting its DIR argument, so caching its
result by (FUNC . DIR) was wrong: two buffers visiting the same
directory but with different file-local overrides would share the
first buffer's cached answer.  Skip the cache for this function
specifically - it's a single variable read, no FS work to amortize.

Adds a regression test that visits two buffers with different
file-local roots from the same default-directory and confirms each
sees its own override.