fix clippy (#10659)

This pr fix clippy warnings in latest clippy version(1.72.0):

Unfortunally it's not easy to handle for [try
fold](https://rust-lang.github.io/rust-clippy/master/index.html#/manual_try_fold)
warning in `start command`

Refer to known issue:
> This lint doesn’t take into account whether a function does something
on the failure case, i.e., whether short-circuiting will affect
behavior. Refactoring to try_fold is not desirable in those cases.

That's the case for our code, which does something on the failure case.

So this pr is making a little refactor on `try_commands`.

crates/nu-command/src/date/parser.rs

@@ -98,7 +98,7 @@ fn timezone_offset_internal(
     };
     match s.len() {
         len if len >= 2 => &s[2..],
-        len if len == 0 => s,
+        0 => s,
         _ => return Err(ParseErrorKind::TooShort),
     };
 

crates/nu-command/src/debug/explain.rs

@@ -90,7 +90,6 @@ pub fn get_pipeline_elements(
             let value_span = value.span();
             let value_span_start = value_span.start as i64;
             let value_span_end = value_span.end as i64;
-            let command_name = command_name;
 
             let record = record! {
                     "cmd_index" => Value::string(index, span),

crates/nu-command/src/filesystem/ls.rs

@@ -158,8 +158,10 @@ impl Command for Ls {
         let glob_options = if all {
             None
         } else {
-            let mut glob_options = MatchOptions::new();
-            glob_options.recursive_match_hidden_dir = false;
+            let glob_options = MatchOptions {
+                recursive_match_hidden_dir: false,
+                ..Default::default()
+            };
             Some(glob_options)
         };
         let (prefix, paths) = nu_engine::glob_from(&glob_path, &cwd, call_span, glob_options)?;

crates/nu-command/src/filesystem/start.rs

@@ -151,40 +151,38 @@ fn try_commands(
     span: Span,
 ) -> Result<(), ShellError> {
     let env_vars_str = env_to_strings(engine_state, stack)?;
-    commands
-        .into_iter()
-        .map(|mut cmd| {
-            let status = cmd
-                .envs(&env_vars_str)
-                .stdin(Stdio::null())
-                .stdout(Stdio::null())
-                .stderr(Stdio::null())
-                .status();
-            match status {
-                Ok(status) if status.success() => Ok(()),
-                Ok(status) => Err(format!(
-                    "\nCommand `{}` failed with {}",
-                    format_command(&cmd),
-                    status
-                )),
-                Err(err) => Err(format!(
-                    "\nCommand `{}` failed with {}",
-                    format_command(&cmd),
-                    err
-                )),
-            }
-        })
-        .take_while_inclusive(|result| result.is_err())
-        .fold(Err("".to_string()), |combined_result, next_result| {
-            combined_result.or_else(|combined_message| {
-                next_result.map_err(|next_message| combined_message + &next_message)
-            })
-        })
-        .map_err(|message| ShellError::ExternalCommand {
-            label: "No command found to start with this path".to_string(),
-            help: "Try different path or install appropriate command\n".to_string() + &message,
-            span,
-        })
+    let cmd_run_result = commands.into_iter().map(|mut cmd| {
+        let status = cmd
+            .envs(&env_vars_str)
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status();
+        match status {
+            Ok(status) if status.success() => Ok(()),
+            Ok(status) => Err(format!(
+                "\nCommand `{}` failed with {}",
+                format_command(&cmd),
+                status
+            )),
+            Err(err) => Err(format!(
+                "\nCommand `{}` failed with {}",
+                format_command(&cmd),
+                err
+            )),
+        }
+    });
+
+    for one_result in cmd_run_result {
+        if let Err(err_msg) = one_result {
+            return Err(ShellError::ExternalCommand {
+                label: "No command found to start with this path".to_string(),
+                help: "Try different path or install appropriate command\n".to_string() + &err_msg,
+                span,
+            });
+        }
+    }
+    Ok(())
 }
 
 fn format_command(command: &std::process::Command) -> String {

crates/nu-command/src/strings/detect_columns.rs

@@ -232,7 +232,7 @@ fn detect_columns(
                 .iter()
                 .take(end_index)
                 .skip(start_index)
-                .map(|v| v.as_string().unwrap_or(String::default()))
+                .map(|v| v.as_string().unwrap_or_default())
                 .join(" ");
             let binding = Value::string(combined, Span::unknown());
             let last_seg = vals.split_off(end_index);

crates/nu-command/src/strings/encode_decode/base64.rs

@@ -107,8 +107,7 @@ fn action(
         Value::Error { .. } => input.clone(),
         Value::Binary { val, .. } => match base64_config.action_type {
             ActionType::Encode => {
-                let mut enc_vec = Vec::new();
-                enc_vec.resize(val.len() * 4 / 3 + 4, 0);
+                let mut enc_vec = vec![0; val.len() * 4 / 3 + 4];
                 let bytes_written = match base64_engine.encode_slice(val, &mut enc_vec) {
                     Ok(bytes_written) => bytes_written,
                     Err(err) => {