feat: skip publish=false pkg when publishing entire workspace (#15525)

### What does this PR try to resolve?

Fixes #15006

This changes how cargo-publish works with the unstable
`-Zpackage-workspace` feature.

Before this, when publishing the entire workspace,
like `cargo publish --workspace`,
if there is a package with `package.pulibsh=false,
it'll fail the entire publish process.

After this, when `--workspace` is passed,
or when publishing the virtual workspace,
the intent is more like “publish all publishable in this workspace”,
so skip `publish=false` packages and proceed to publish others.

The new overall behavior looks like this:

* `cargo publish` (inside a `package.publish = false` package): error
* `cargo publish -p publishable -p unpublishable`: error
* `cargo publish --workspace`: skips `package.publish = false

See
#15006 (comment)

### How should we test and review this PR?

* `workspace_flag_with_unpublishable_packages` was added to ensure
`--workspace` work with non-virtual workspace.
* `unpublishable_package_as_versioned_dev_dep` was added to ensure
versioned dev-dependencies won't be skipped and still fail
cargo-publish, as they are required to be published.

There is a new scenario that nothing is going to publish.
I went with a warning instead of hard error because missing publish for
the entire worspace should be a fairly visible. However, this is open
for future to configure via Cargo lint system.

Author: epage

src/cargo/ops/registry/publish.rs

@@ -93,6 +93,46 @@ pub fn publish(ws: &Workspace<'_>, opts: &PublishOpts<'_>) -> CargoResult<()> {
         .filter(|(m, _)| specs.iter().any(|spec| spec.matches(m.package_id())))
         .collect();
 
+    let (unpublishable, pkgs): (Vec<_>, Vec<_>) = pkgs
+        .into_iter()
+        .partition(|(pkg, _)| pkg.publish() == &Some(vec![]));
+    // If `--workspace` is passed,
+    // the intent is more like "publish all publisable packages in this workspace",
+    // so skip `publish=false` packages.
+    let allow_unpublishable = multi_package_mode
+        && match &opts.to_publish {
+            Packages::Default => ws.is_virtual(),
+            Packages::All(_) => true,
+            Packages::OptOut(_) => true,
+            Packages::Packages(_) => false,
+        };
+    if !unpublishable.is_empty() && !allow_unpublishable {
+        bail!(
+            "{} cannot be published.\n\
+            `package.publish` must be set to `true` or a non-empty list in Cargo.toml to publish.",
+            unpublishable
+                .iter()
+                .map(|(pkg, _)| format!("`{}`", pkg.name()))
+                .join(", "),
+        );
+    }
+
+    if pkgs.is_empty() {
+        if allow_unpublishable {
+            let n = unpublishable.len();
+            let plural = if n == 1 { "" } else { "s" };
+            ws.gctx().shell().warn(format_args!(
+                "nothing to publish, but found {n} unpublishable package{plural}"
+            ))?;
+            ws.gctx().shell().note(format_args!(
+                "to publish packages, set `package.publish` to `true` or a non-empty list"
+            ))?;
+            return Ok(());
+        } else {
+            unreachable!("must have at least one publishable package");
+        }
+    }
+
     let just_pkgs: Vec<_> = pkgs.iter().map(|p| p.0).collect();
     let reg_or_index = match opts.reg_or_index.clone() {
         Some(r) => {
@@ -705,19 +745,6 @@ fn package_list(pkgs: impl IntoIterator<Item = PackageId>, final_sep: &str) -> S
 }
 
 fn validate_registry(pkgs: &[&Package], reg_or_index: Option<&RegistryOrIndex>) -> CargoResult<()> {
-    let unpublishable = pkgs
-        .iter()
-        .filter(|pkg| pkg.publish() == &Some(Vec::new()))
-        .map(|pkg| format!("`{}`", pkg.name()))
-        .collect::<Vec<_>>();
-    if !unpublishable.is_empty() {
-        bail!(
-            "{} cannot be published.\n\
-            `package.publish` must be set to `true` or a non-empty list in Cargo.toml to publish.",
-            unpublishable.join(", ")
-        );
-    }
-
     let reg_name = match reg_or_index {
         Some(RegistryOrIndex::Registry(r)) => Some(r.as_str()),
         None => Some(CRATES_IO_REGISTRY),