Keep copy_tree from following dir symlinks

27 of the 28 replaced copiers checked entry.file_type(), which does
not follow symlinks; only yarn_berry_common followed them. Following
them lets a link cycle in an installed tree recurse until the stack
overflows. The shared copy now checks file_type() like the majority.
yarn_berry_common copies .socket and the yarn zip cache, which hold
no directory links. The module doc no longer claims a re-export.

Assisted-by: Claude Code:claude-opus-5-5

Author: claude

crates/socket-patch-cli/tests/common/fs_tree.rs

@@ -1,21 +1,22 @@
-//! Recursive directory copy for test fixtures. `common/mod.rs` re-exports
-//! it; shared modules whose includers don't all declare `mod common` pull
-//! this file in on its own with `#[path = "../common/fs_tree.rs"] mod
-//! fs_tree;`.
+//! Recursive directory copy for test fixtures, reached as
+//! `common::fs_tree::copy_tree`. Shared modules whose includers don't all
+//! declare `mod common` pull this file in on its own with
+//! `#[path = "../common/fs_tree.rs"] mod fs_tree;`.
 
 #![allow(dead_code)]
 
 use std::path::Path;
 
-/// Copy `src` into `dst`, creating `dst`. Symlinks are followed: a link to
-/// a directory is copied as a directory, a link to a file as the file.
-/// Panics if `src` is not a readable directory.
+/// Copy `src` into `dst`, creating `dst`. A symlink to a file is copied as
+/// the file; a symlink to a directory panics rather than being followed,
+/// so a link cycle in an installed tree can't recurse forever. Panics if
+/// `src` is not a readable directory.
 pub fn copy_tree(src: &Path, dst: &Path) {
     std::fs::create_dir_all(dst).unwrap();
     for entry in std::fs::read_dir(src).unwrap() {
         let entry = entry.unwrap();
         let to = dst.join(entry.file_name());
-        if entry.path().is_dir() {
+        if entry.file_type().unwrap().is_dir() {
             copy_tree(&entry.path(), &to);
         } else {
             std::fs::copy(entry.path(), &to).unwrap();