refactor(fs): Stop fabricating inode 0 for in-memory resources

createStat() previously returned a synthetic statInfo with ino: 0, which
Resource.clone() forwarded as statInfo into the new instance. The
constructor's `this.#inode ??= statInfo.ino` then set the clone's inode
to 0, so memory-only resources read through Memory.byPath / Memory.byGlob
advertised a fabricated inode. That defeated the inode short-circuit in
the build cache's isResourceUnchanged whenever cached metadata was later
compared against an FS-backed read of the same path.

Set ino to undefined in createStat() so memory-only resources and their
clones report getInode() === undefined, leaving the cache to fall back
on size + lastModified + integrity.

Add Resource tests covering inode propagation through construction,
clone, and setBuffer for both memory-only and FS-backed resources.

Author: RandomByte

packages/fs/lib/Resource.js

@@ -954,7 +954,7 @@ function createStat(size, isDirectory = false, lastModified) {
 		isSymbolicLink: fnFalse,
 		isFIFO: fnFalse,
 		isSocket: fnFalse,
-		ino: 0,
+		ino: undefined,
 		size, // Might be undefined
 		atimeMs: now.getTime(),
 		mtimeMs: mtime.getTime(),

packages/fs/test/lib/Resource.js

@@ -1979,3 +1979,65 @@ test("getIntegrity: Works with large content", async (t) => {
 	t.is(integrity, "sha256-j5kLoLV3tRzwCeoEk2jBa72hsh4bk74HqCR1i7JTw5s=",
 		"Correct integrity for large content");
 });
+
+test("getInode: Memory-only resource returns undefined", (t) => {
+	const resource = new Resource({
+		path: "/my/path/to/resource",
+		string: "content"
+	});
+
+	t.is(resource.getInode(), undefined,
+		"Resource constructed without statInfo or inode must not advertise an inode");
+});
+
+test("getInode: Clone of memory-only resource returns undefined", async (t) => {
+	const resource = new Resource({
+		path: "/my/path/to/resource",
+		string: "content"
+	});
+
+	const clone = await resource.clone();
+
+	t.is(clone.getInode(), undefined,
+		"Clone must not fabricate an inode for a memory-only resource");
+});
+
+test("getInode: FS-backed resource returns the real inode", async (t) => {
+	const fsPath = path.join("test", "fixtures", "application.a", "webapp", "index.html");
+	const statInfo = await stat(fsPath);
+	const resource = new Resource({
+		path: "/app/index.html",
+		statInfo,
+		createStream: () => createReadStream(fsPath)
+	});
+
+	t.is(resource.getInode(), statInfo.ino,
+		"Resource constructed with statInfo carries the real inode");
+});
+
+test("getInode: Clone of FS-backed resource preserves the inode", async (t) => {
+	const resource = createBasicResource();
+	const inode = resource.getInode();
+
+	const clone = await resource.clone();
+
+	t.not(inode, undefined, "Sanity: original resource has an inode");
+	t.is(clone.getInode(), inode,
+		"Clone preserves the inode of an FS-backed resource");
+});
+
+test("getInode: Preserved across setBuffer", (t) => {
+	const fsPath = path.join("test", "fixtures", "application.a", "webapp", "index.html");
+	const statInfo = statSync(fsPath);
+	const resource = new Resource({
+		path: "/app/index.html",
+		statInfo,
+		buffer: Buffer.from("original")
+	});
+	const inode = resource.getInode();
+
+	resource.setBuffer(Buffer.from("modified"));
+
+	t.is(resource.getInode(), inode,
+		"Inode is unchanged after setBuffer (same on-disk slot, content modified)");
+});