metro-file-map: Create fileMapCacheDirectory if it doesn't exist

If `fileMapCacheDirectory` points at a directory that doesn't exist yet, the file map cache is never written, so every restart crawls the project from scratch. The only sign is a warning at startup:

```
[metro-file-map] Cache write error
: Error: ENOENT: no such file or directory, open '/path/to/project/node_modules/.cache/metro-file-map/metro-file-map-<hash>-<hash>'
```

The default, `os.tmpdir()`, always exists, so this only affects a custom directory - but a project-local one like `node_modules/.cache/metro-file-map` won't exist after any fresh install. The transform cache doesn't have this problem, because `FileStore` creates its directory when a write fails with `ENOENT`.

This change does the same in `DiskCacheManager`: on `ENOENT`, create the directory (recursively) and retry the write once. Writes into an existing directory are unchanged.

Changelog:
```
 - **[Fix]**: Create `fileMapCacheDirectory` if it doesn't exist, rather than failing to persist the file map cache
```

Test plan:
New test in `DiskCacheManager-test.js` where the first write fails with `ENOENT`, asserting that the directory is created and the snapshot written without an error. It fails before this change and passes after.

Also checked end-to-end with `createFileMap` and `fileMapCacheDirectory` set to a missing `<project>/node_modules/.cache/metro-file-map`: before, the warning above and no directory; after, no warning and the cache file is written.

```
yarn jest packages/metro-file-map packages/metro/src/node-haste packages/metro/src/DeltaBundler
yarn flow check
yarn eslint packages/metro-file-map
yarn verify-api-snapshots
```

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: shubh73

packages/metro-file-map/src/cache/DiskCacheManager.js

@@ -115,7 +115,19 @@ export class DiskCacheManager implements CacheManager {
           }
           const data = getSnapshot();
           this.#hasUnwrittenChanges = false;
-          await fsPromises.writeFile(this.#cachePath, serialize(data));
+          const serialized = serialize(data);
+          try {
+            await fsPromises.writeFile(this.#cachePath, serialized);
+          } catch (e) {
+            if (e?.code !== 'ENOENT') {
+              throw e;
+            }
+            // The cache directory doesn't exist yet - create it and retry.
+            await fsPromises.mkdir(path.dirname(this.#cachePath), {
+              recursive: true,
+            });
+            await fsPromises.writeFile(this.#cachePath, serialized);
+          }
           debug('Written cache to %s', this.#cachePath);
         })
         .catch(onWriteError);

packages/metro-file-map/src/cache/__tests__/DiskCacheManager-test.js

@@ -21,11 +21,13 @@ import EventEmitter from 'node:events';
 import * as path from 'node:path';
 import {serialize} from 'node:v8';
 
+const mockMkdir = jest.fn();
 const mockReadFile = jest.fn();
 const mockWriteFile = jest.fn();
 
 jest.mock('node:fs', () => ({
   promises: {
+    mkdir: (...args) => mockMkdir(...args),
     readFile: (...args) => mockReadFile(...args),
     writeFile: (...args) => mockWriteFile(...args),
   },
@@ -189,6 +191,35 @@ describe('cacheManager', () => {
     );
   });
 
+  test('creates the cache directory if it does not exist', async () => {
+    const cacheManager = new DiskCacheManager({buildParameters}, defaultConfig);
+    const getSnapshot = jest.fn(
+      () =>
+        ({
+          clocks: new Map([['foo', 'bar']]),
+          fileSystemData: new Map(),
+          plugins: new Map(),
+        }) as CacheData,
+    );
+    mockWriteFile.mockRejectedValueOnce({code: 'ENOENT'});
+    const onWriteError = jest.fn();
+    await cacheManager.write(getSnapshot, {
+      changedSinceCacheRead: true,
+      eventSource: {onChange: () => () => {}},
+      onWriteError,
+    });
+    expect(mockMkdir).toHaveBeenCalledWith(
+      path.dirname(cacheManager.getCacheFilePath()),
+      {recursive: true},
+    );
+    expect(mockWriteFile).toHaveBeenCalledTimes(2);
+    expect(mockWriteFile).toHaveBeenLastCalledWith(
+      cacheManager.getCacheFilePath(),
+      serialize(getSnapshot()),
+    );
+    expect(onWriteError).not.toHaveBeenCalled();
+  });
+
   test('does not write when there have been no changes', async () => {
     const cacheManager = new DiskCacheManager({buildParameters}, defaultConfig);
     const getSnapshot = jest.fn(