fix(package): exclude target/package from backups

  ### What does this PR try to resolve?

  The target directory is not excluded from backups when created with
  `cargo package` or `cargo publish`. This causes the `target/package`
  directory to be included in Time Machine backups on macOS and other
  backup systems that respect CACHEDIR.TAG files.

  The issue occurs because when `Filesystem::open()` creates parent
  directories in `src/cargo/util/flock.rs:336`, it uses
  `paths::create_dir_all()` instead of the backup-excluding version,
  bypassing the normal target directory creation logic.

  This commit adds a new `create_dir_with_backup_exclusion()` method to
  `Filesystem` and uses it to ensure the `target/package` directory is
  properly excluded from backups before creating files in it.

  Fixes #16238

  ### How to test and review this PR?

  Run the following:
  cargo new foo
  cd foo
  cargo package --allow-dirty
  ls -al target/package/

  Verify that `CACHEDIR.TAG` now exists in `target/package/`.

  All existing package tests pass.

Author: SepehrGanji

src/cargo/ops/cargo_package/mod.rs

@@ -162,6 +162,7 @@ fn create_package(
 
     let filename = pkg.package_id().tarball_name();
     let dir = ws.build_dir().join("package");
+    dir.create_dir_with_backup_exclusion()?;
     let mut dst = {
         let tmp = format!(".{}", filename);
         dir.open_rw_exclusive_create(&tmp, gctx, "package scratch space")?
@@ -226,6 +227,7 @@ pub fn package(ws: &Workspace<'_>, opts: &PackageOpts<'_>) -> CargoResult<Vec<Fi
     } else {
         // Uplifting artifacts
         let artifact_dir = target_dir.join("package");
+        artifact_dir.create_dir_with_backup_exclusion()?;
         for (pkg, _, src) in packaged {
             let filename = pkg.package_id().tarball_name();
             let dst =
@@ -1128,7 +1130,7 @@ struct TmpRegistry<'a> {
 
 impl<'a> TmpRegistry<'a> {
     fn new(gctx: &'a GlobalContext, root: Filesystem, upstream: SourceId) -> CargoResult<Self> {
-        root.create_dir()?;
+        root.create_dir_with_backup_exclusion()?;
         let _lock = root.open_rw_exclusive_create(".cargo-lock", gctx, "temporary registry")?;
         let slf = Self {
             gctx,

src/cargo/util/flock.rs

@@ -211,6 +211,17 @@ impl Filesystem {
         paths::create_dir_all(&self.root)
     }
 
+    /// Creates the directory pointed to by this filesystem, excluding it from backups.
+    ///
+    /// This should be used for target directories and other build artifacts that
+    /// should not be included in backups or Time Machine on macOS.
+    ///
+    /// Handles errors where other Cargo processes are also attempting to
+    /// concurrently create this directory.
+    pub fn create_dir_with_backup_exclusion(&self) -> CargoResult<()> {
+        paths::create_dir_all_excluded_from_backups_atomic(&self.root)
+    }
+
     /// Returns an adaptor that can be used to print the path of this
     /// filesystem.
     pub fn display(&self) -> Display<'_> {