feat: improve directory removal on Linux for permission denied

Enhance safe_remove_dir_recursive_impl to handle PermissionDenied errors when opening unreadable directories by attempting direct removal via parent directory file descriptor. This improves robustness for cases where directories cannot be read internally, allowing successful deletion without read permissions.

Author: mattsu2020

src/uu/rm/src/platform/linux.rs

@@ -361,8 +361,40 @@ pub fn safe_remove_dir_recursive_impl(
             let child_dir_fd = match DirFd::open(&entry_path) {
                 Ok(fd) => fd,
                 Err(e) => {
-                    error = handle_error_with_force(e, &entry_path, options) || error;
-                    continue;
+                    if e.kind() == std::io::ErrorKind::PermissionDenied {
+                        // Try to remove the unreadable directory directly via parent dirfd
+                        match DirFd::open(path) {
+                            Ok(parent_fd) => {
+                                match parent_fd.unlink_at(entry_name.as_ref(), true) {
+                                    Ok(_) => {
+                                        if let Some(pb) = progress_bar {
+                                            pb.inc(1);
+                                        }
+                                        verbose_removed_directory(&entry_path, options);
+                                        continue;
+                                    }
+                                    Err(remove_err) => {
+                                        if remove_err.kind() == std::io::ErrorKind::PermissionDenied {
+                                            if !options.force {
+                                                show_permission_denied_error(&entry_path);
+                                            }
+                                            error = !options.force || error;
+                                        } else {
+                                            error = handle_error_with_force(remove_err, &entry_path, options) || error;
+                                        }
+                                        continue;
+                                    }
+                                }
+                            }
+                            Err(parent_e) => {
+                                error = handle_error_with_force(parent_e, &entry_path, options) || error;
+                                continue;
+                            }
+                        }
+                    } else {
+                        error = handle_error_with_force(e, &entry_path, options) || error;
+                        continue;
+                    }
                 }
             };