Make Python install robust to individual failures (#5199)

## Summary

We have roughly this code for uninstalls, but for installs, we eject as
soon as we hit a failure, leaving some things in a partial state.

crates/uv/src/commands/python/install.rs

@@ -158,24 +158,44 @@ pub(crate) async fn install(
         .collect::<Vec<_>>()
         .await;
 
+    let mut failed = false;
     for (version, result) in results {
-        let path = match result? {
-            // We should only encounter already-available during concurrent installs
-            DownloadResult::AlreadyAvailable(path) => path,
-            DownloadResult::Fetched(path) => {
+        match result {
+            Ok(download) => {
+                let path = match download {
+                    // We should only encounter already-available during concurrent installs
+                    DownloadResult::AlreadyAvailable(path) => path,
+                    DownloadResult::Fetched(path) => {
+                        writeln!(
+                            printer.stderr(),
+                            "Installed {} to: {}",
+                            format!("Python {version}").cyan(),
+                            path.user_display().cyan()
+                        )?;
+                        path
+                    }
+                };
+
+                // Ensure the installations have externally managed markers
+                let installed = ManagedPythonInstallation::new(path.clone())?;
+                installed.ensure_externally_managed()?;
+            }
+            Err(err) => {
+                failed = true;
                 writeln!(
                     printer.stderr(),
-                    "Installed {} to: {}",
-                    format!("Python {version}").cyan(),
-                    path.user_display().cyan()
+                    "Failed to install {}: {err}",
+                    version.green()
                 )?;
-                path
             }
-        };
+        }
+    }
 
-        // Ensure the installations have externally managed markers
-        let installed = ManagedPythonInstallation::new(path.clone())?;
-        installed.ensure_externally_managed()?;
+    if failed {
+        if downloads.len() > 1 {
+            writeln!(printer.stderr(), "Failed to install some Python versions")?;
+        }
+        return Ok(ExitStatus::Failure);
     }
 
     let s = if downloads.len() == 1 { "" } else { "s" };

crates/uv/src/commands/python/uninstall.rs

@@ -103,16 +103,17 @@ pub(crate) async fn uninstall(
         return Ok(ExitStatus::Failure);
     }
 
-    let tasks = futures::stream::iter(matching_installations.iter())
+    let results = futures::stream::iter(matching_installations.iter())
         .map(|installation| async {
             (
                 installation.key(),
                 fs_err::tokio::remove_dir_all(installation.path()).await,
             )
         })
-        .buffered(4);
+        .buffered(4)
+        .collect::<Vec<_>>()
+        .await;
 
-    let results = tasks.collect::<Vec<_>>().await;
     let mut failed = false;
     for (key, result) in results.iter().sorted_by_key(|(key, _)| key) {
         if let Err(err) = result {