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.

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.

## Benchmark
Replaying every `DependencyGraph.resolveDependency` call made by one iOS dev build of the benchmark app. 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).
 - ~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` is restructured around the new contract: the closest package is looked up on every call, a change of closest package is reflected with no invalidation, each `package.json` is parsed once however many modules share it, and invalidating one re-reads it. Tests of the reverse index and the no-package set go with those structures.

**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.

Changelog: Internal

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();
-    }
   }
 }