Follow links when cache-key is a glob (#13438)

## Summary

There's some inconsistent behaviour in handling symlinks when
`cache-key` is a glob or a file path. This PR attempts to address that.

- When cache-key is a path,
[`Path::metadata()`](https://doc.rust-lang.org/std/path/struct.Path.html#method.metadata)
is used to check if it's a file or not. According to the docs:
> This function will traverse symbolic links to query information about
the destination file.

So, if the target file is a symlink, it will be resolved and the
metadata will be queried for the underlying file.

- When cache-key is a glob, `globwalk` is used, specifically allowing
for symlinks:

  ```rust
  .file_type(globwalk::FileType::FILE | globwalk::FileType::SYMLINK)
  ```

- However, without enabling link following, `DirEntry::metadata()` will
return an equivalent of `Path::symlink_metadata()` (and not
`Path::metadata()`), which will have a file type that looks like

   ```rust
   FileType {
       is_file: false,
       is_dir: false,
       is_symlink: true,
      ..
    }
    ```

- Then, there's a check for `metadata.is_file()` which fails and
complains that the target entry "is a directory when file was expected".

- TLDR: glob cache-keys don't work with symlinks.

## Solutions

Option 1 (current PR): follow symlinks.

Option 2 (also doable): don't follow symlinks, but resolve the resulting
target entry manually in case its file type is a symlink. However, this
would be a little weird and unobvious in that we resolve files but not
directories for some reason. Also, symlinking directories is pretty
useful if you want to symlink directories of local dependencies that are
not under the project's path.

## Test Plan

This has been tested manually:

```rust
fn main() {
    for follow_links in [false, true] {
        let walker = globwalk::GlobWalkerBuilder::from_patterns(".", &["a/*"])
            .file_type(globwalk::FileType::FILE | globwalk::FileType::SYMLINK)
            .follow_links(follow_links)
            .build()
            .unwrap();
        let entry = walker.into_iter().next().unwrap().unwrap();
        dbg!(&entry);
        dbg!(entry.file_type());
        dbg!(entry.path_is_symlink());
        dbg!(entry.path());
        let meta = entry.metadata().unwrap();
        dbg!(meta.is_file());
    }

    let path = std::path::PathBuf::from("./a/b");
    dbg!(path.metadata().unwrap().file_type());
    dbg!(path.symlink_metadata().unwrap().file_type());
}
```

Current behaviour (glob cache-key, don't follow links):
```
[src/main.rs:9:9] &entry = DirEntry("./a/b")
[src/main.rs:10:9] entry.file_type() = FileType {
    is_file: false,
    is_dir: false,
    is_symlink: true,
    ..
}
[src/main.rs:11:9] entry.path_is_symlink() = true
[src/main.rs:12:9] entry.path() = "./a/b"
[src/main.rs:14:9] meta.is_file() = false
```

Glob cache-key, follow links:
```
[src/main.rs:9:9] &entry = DirEntry("./a/b")
[src/main.rs:10:9] entry.file_type() = FileType {
    is_file: true,
    is_dir: false,
    is_symlink: false,
    ..
}
[src/main.rs:11:9] entry.path_is_symlink() = true
[src/main.rs:12:9] entry.path() = "./a/b"
[src/main.rs:14:9] meta.is_file() = true
```

Using `path.metadata()` for a non-glob cache key:
```
[src/main.rs:18:5] path.metadata().unwrap().file_type() = FileType {
    is_file: true,
    is_dir: false,
    is_symlink: false,
    ..
}
[src/main.rs:19:5] path.symlink_metadata().unwrap().file_type() = FileType {
    is_file: false,
    is_dir: false,
    is_symlink: true,
    ..
}
```

Author: aldanor

Cargo.lock

@@ -24,3 +24,7 @@ thiserror = { workspace = true }
 toml = { workspace = true }
 tracing = { workspace = true }
 walkdir = { workspace = true }
+
+[dev-dependencies]
+anyhow = { workspace = true }
+tempfile = { workspace = true }

crates/uv-cache-info/Cargo.toml

@@ -230,18 +230,32 @@ impl CacheInfo {
                             continue;
                         }
                     };
-                    let metadata = match entry.metadata() {
-                        Ok(metadata) => metadata,
-                        Err(err) => {
-                            warn!("Failed to read metadata for glob entry: {err}");
-                            continue;
+                    let metadata = if entry.path_is_symlink() {
+                        // resolve symlinks for leaf entries without following symlinks while globbing
+                        match fs_err::metadata(entry.path()) {
+                            Ok(metadata) => metadata,
+                            Err(err) => {
+                                warn!("Failed to resolve symlink for glob entry: {err}");
+                                continue;
+                            }
+                        }
+                    } else {
+                        match entry.metadata() {
+                            Ok(metadata) => metadata,
+                            Err(err) => {
+                                warn!("Failed to read metadata for glob entry: {err}");
+                                continue;
+                            }
                         }
                     };
                     if !metadata.is_file() {
-                        warn!(
-                            "Expected file for cache key, but found directory: `{}`",
-                            entry.path().display()
-                        );
+                        if !entry.path_is_symlink() {
+                            // don't warn if it was a symlink - it may legitimately resolve to a directory
+                            warn!(
+                                "Expected file for cache key, but found directory: `{}`",
+                                entry.path().display()
+                            );
+                        }
                         continue;
                     }
                     timestamp = max(timestamp, Some(Timestamp::from_metadata(&metadata)));
@@ -346,3 +360,71 @@ enum DirectoryTimestamp {
     Timestamp(Timestamp),
     Inode(u64),
 }
+
+#[cfg(all(test, unix))]
+mod tests_unix {
+    use anyhow::Result;
+
+    use super::{CacheInfo, Timestamp};
+
+    #[test]
+    fn test_cache_info_symlink_resolve() -> Result<()> {
+        let dir = tempfile::tempdir()?;
+        let dir = dir.path().join("dir");
+        fs_err::create_dir_all(&dir)?;
+
+        let write_manifest = |cache_key: &str| {
+            fs_err::write(
+                dir.join("pyproject.toml"),
+                format!(
+                    r#"
+                [tool.uv]
+                cache-keys = [
+                    "{cache_key}"
+                ]
+                "#
+                ),
+            )
+        };
+
+        let touch = |path: &str| -> Result<_> {
+            let path = dir.join(path);
+            fs_err::create_dir_all(path.parent().unwrap())?;
+            fs_err::write(&path, "")?;
+            Ok(Timestamp::from_metadata(&path.metadata()?))
+        };
+
+        let cache_timestamp = || -> Result<_> { Ok(CacheInfo::from_directory(&dir)?.timestamp) };
+
+        write_manifest("x/**")?;
+        assert_eq!(cache_timestamp()?, None);
+        let y = touch("x/y")?;
+        assert_eq!(cache_timestamp()?, Some(y));
+        let z = touch("x/z")?;
+        assert_eq!(cache_timestamp()?, Some(z));
+
+        // leaf entry symlink should be resolved
+        let a = touch("../a")?;
+        fs_err::os::unix::fs::symlink(dir.join("../a"), dir.join("x/a"))?;
+        assert_eq!(cache_timestamp()?, Some(a));
+
+        // symlink directories should not be followed while globbing
+        let c = touch("../b/c")?;
+        fs_err::os::unix::fs::symlink(dir.join("../b"), dir.join("x/b"))?;
+        assert_eq!(cache_timestamp()?, Some(a));
+
+        // no globs, should work as expected
+        write_manifest("x/y")?;
+        assert_eq!(cache_timestamp()?, Some(y));
+        write_manifest("x/a")?;
+        assert_eq!(cache_timestamp()?, Some(a));
+        write_manifest("x/b/c")?;
+        assert_eq!(cache_timestamp()?, Some(c));
+
+        // symlink pointing to a directory
+        write_manifest("x/*b*")?;
+        assert_eq!(cache_timestamp()?, None);
+
+        Ok(())
+    }
+}