Remove PackageCache's per-module closest package memo

Stacked on #1946.

## Summary
`PackageCache` remembers the closest `package.json` for every module path it's asked about, with a reverse index from each `package.json` to the module paths under it and a set of paths known to have no package, both of which exist only to invalidate the first. `DependencyGraph` calls `invalidate` for every changed file to keep it honest.

With the previous two PRs that memo no longer pays for itself. #1945 cut closest-package lookups 3.7x (64k -> 17k per build on our mid-size RN benchmark app*), and #1946 made each one a walk of single map lookups, 2.1x faster (870ns -> 406ns). This removes the memo and both indices, and looks up the closest package on every call. The parsed contents of each `package.json` are still cached per path, and `invalidate` now just drops those.

The other reason to do this is incremental resolution (#1944). Any cache that sits between the resolver and the file system has to store the observations that produced each entry and replay them on a hit, or the second resolution to hit the cache can never be invalidated. That's a fair amount of machinery to add to a cache that's worth 3% of first-build resolution time, which is itself a small part of a build.

This only makes sense on top of the stack - at #1944, removing the memo costs 14% on a first pass, and nearly doubles a pass that re-resolves everything.

\* Described in the test plan.

## Bugs fixed
This also fixes two invalidation bugs, both present on main, where the watcher picks up a change on disk but resolution keeps its old answer until Metro restarts:
 - A nearer `package.json` is added, e.g. creating a nested package in a monorepo. The memo is invalidated through a reverse index from each `package.json` to the modules that resolved to it, and a new `package.json` has no entries, so the modules beneath it keep pointing at the farther one. (It's masked when there was previously no enclosing package at all, which is special-cased.)
 - A directory symlink is retargeted into another package. Entries are keyed by the path as it was asked for, through the link, and only the link's own path is invalidated.

Both changes reset the graph, so everything is re-resolved - against the stale memo, which is probably why they've gone unnoticed. Reproduced with a real `DependencyGraph` and watcher on main and on #1946, using a `browser` redirect in the affected `package.json` to show which one was consulted. With no memo there's nothing to go stale - every lookup walks the live file map.

## Benchmark
Resolution time in isolation, replaying every `DependencyGraph.resolveDependency` call made by one iOS dev build of the benchmark app. Nothing is transformed or serialised, so these are percentages of resolution, not of a build. This goes through `DependencyGraph`'s whole-resolution cache, which is cleared only by real file change events, so each row is something that actually happens in a session. 7 interleaved rounds, medians of 15 iterations. Resolver output is byte-identical.

| scenario | #1946 | this diff |
|---|---|---|
| first build (ms) | 92.9 | 95.6 (+2.9%) |
| rebuild, nothing changed (ms) | 7.58 | 7.61 |
| after a source edit, re-resolving the edited module's 8 dependencies (µs) | 155 | 155 |
| after a `package.json` change, re-resolving everything (ms) | 73.6 | 80.4 (+9.3%) |
| heap retained after resolving (MB) | 3.0 | **1.9 (−37%)** |

The tradeoffs are:
 - ~3% of resolution time on a first build (3ms here). A real build does far more than resolve - the same build takes around 4s end to end with a warm transform cache - so that's under 0.1% of it.
 - ~9% (7ms here) when a `package.json` or symlink change resets the whole graph, which is the only time everything is re-resolved against a warm `PackageCache`. Incremental resolution aims to remove those full resets.
 - Nothing on an ordinary edit. Metro re-resolves only the edited module's dependencies, and the difference there is within noise.

## Test plan
```
yarn jest packages/metro-file-map packages/metro-resolver packages/metro/src/node-haste packages/metro/src/DeltaBundler packages/metro/src/integration_tests
yarn flow check
yarn verify-api-snapshots
```
`PackageCache-test.js` loses its tests of memo invalidation, along with the structures they tested - with no memo, invalidation is a non-issue by construction. What's left covers the one remaining cache: each `package.json` is parsed once however many modules share it, and is re-read after it's invalidated.

**Benchmark app** - a synthetic mid-size RN 0.87 app: 23 common dependencies (Reanimated, React Navigation, TanStack Query, lodash, etc.) and ~1,000 generated first-party modules, 60% of them in a workspace package outside `projectRoot` with its own `node_modules`. The iOS dev bundle is 2.8k modules, from a file map of 34k files. Timings replay the `resolveDependency` calls a real build of it makes against a fresh `DependencyGraph` per process, in interleaved rounds, with source and `package.json` edits made on disk and picked up by the watcher. These timings isolate resolution - no transformation, serialisation or file reads are included. A real build of this app takes around 4s even with a warm transform cache, so resolution is about 2% of it.

Changelog:
```
 - **[Fix]**: Resolver: Fix stale resolutions after adding a nearer `package.json` or retargeting a symlinked directory, which previously needed a restart
```

Author: robhogan

packages/metro/src/node-haste/PackageCache.js

@@ -12,7 +12,7 @@
 import type {PackageJson} from 'metro-resolver/private/types';
 
 import {readFileSync} from 'node:fs';
-import {dirname, sep} from 'node:path';
+import {dirname} from 'node:path';
 
 type GetClosestPackageFn = (absoluteFilePath: string) => ?{
   packageJsonPath: string,
@@ -40,12 +40,6 @@ export class PackageCache {
       packageJson: PackageJson,
     },
   >;
-  // Single cache: module path → pre-built result object, or null (no allocation on hit)
-  #resultByModulePath: Map<string, PackageForModule | null>;
-  // Reverse index for invalidation: package.json path → set of module paths
-  #modulePathsByPackagePath: Map<string, Set<string>>;
-  // Module paths that resolved to no package.json (null), for invalidation
-  #modulePathsWithNoPackage: Set<string>;
 
   constructor(options: {
     getClosestPackage: GetClosestPackageFn,
@@ -55,9 +49,6 @@ export class PackageCache {
     this.#getClosestPackage = options.getClosestPackage;
     this.#readPackageJson = options.readPackageJson ?? readPackageJsonSync;
     this.#packageCache = new Map();
-    this.#resultByModulePath = new Map();
-    this.#modulePathsByPackagePath = new Map();
-    this.#modulePathsWithNoPackage = new Set();
   }
 
   getPackage(filePath: string): Readonly<{
@@ -75,86 +66,24 @@ export class PackageCache {
     return cached;
   }
 
+  /**
+   * The closest package is looked up on every call rather than remembered per
+   * module path. Only the parsed contents of each `package.json` are cached.
+   */
   getPackageForModule(absoluteModulePath: string): ?PackageForModule {
-    const cached = this.#resultByModulePath.get(absoluteModulePath);
-
-    // Distinguish between `null` (positively no closest package) and
-    // `undefined` (no cached result yet)
-    // eslint-disable-next-line lint/strictly-null
-    if (cached !== undefined) {
-      return cached;
-    }
-
     const closest = this.#getClosestPackage(absoluteModulePath);
     if (closest == null) {
-      this.#resultByModulePath.set(absoluteModulePath, null);
-      this.#modulePathsWithNoPackage.add(absoluteModulePath);
-      return null;
-    }
-
-    const packagePath = closest.packageJsonPath;
-
-    // Track module→package for invalidation
-    let modulePaths = this.#modulePathsByPackagePath.get(packagePath);
-    if (modulePaths == null) {
-      modulePaths = new Set();
-      this.#modulePathsByPackagePath.set(packagePath, modulePaths);
-    }
-    modulePaths.add(absoluteModulePath);
-
-    const pkg = this.getPackage(packagePath);
-    if (pkg == null) {
       return null;
     }
-
-    // Cache the pre-built result object — no allocation on future hits
-    const result: PackageForModule = {
+    const pkg = this.getPackage(closest.packageJsonPath);
+    return {
       packageJson: pkg.packageJson,
       packageRelativePath: closest.packageRelativePath,
       rootPath: pkg.rootPath,
     };
-    this.#resultByModulePath.set(absoluteModulePath, result);
-    return result;
   }
 
   invalidate(filePath: string) {
     this.#packageCache.delete(filePath);
-
-    // Clean up any cached result for this module path (including null).
-    // Derive the package.json path from the cached result to clean up the
-    // reverse index.
-    const cachedResult = this.#resultByModulePath.get(filePath);
-    this.#resultByModulePath.delete(filePath);
-    this.#modulePathsWithNoPackage.delete(filePath);
-
-    if (cachedResult != null) {
-      const packagePath = cachedResult.rootPath + sep + 'package.json';
-      const modules = this.#modulePathsByPackagePath.get(packagePath);
-      if (modules != null) {
-        modules.delete(filePath);
-        if (modules.size === 0) {
-          this.#modulePathsByPackagePath.delete(packagePath);
-        }
-      }
-    }
-
-    // If filePath is a package.json, invalidate all module lookups pointing to it
-    const modulePaths = this.#modulePathsByPackagePath.get(filePath);
-    if (modulePaths != null) {
-      for (const modulePath of modulePaths) {
-        this.#resultByModulePath.delete(modulePath);
-      }
-      this.#modulePathsByPackagePath.delete(filePath);
-    }
-
-    // If a package.json was created, modified, or deleted, invalidate all
-    // null-cached module results, since modules that previously had no
-    // enclosing package.json may now resolve to this one.
-    if (filePath.endsWith(sep + 'package.json')) {
-      for (const modulePath of this.#modulePathsWithNoPackage) {
-        this.#resultByModulePath.delete(modulePath);
-      }
-      this.#modulePathsWithNoPackage.clear();
-    }
   }
 }