open, rm, umv, cp, rm and du: Don't globs if inputs are variables or string interpolation (#11886)

# Description
This is a follow up to
https://github.com/nushell/nushell/pull/11621#issuecomment-1937484322

Also Fixes: #11838 

## About the code change
It applys the same logic when we pass variables to external commands:


0487e9ffcb/crates/nu-command/src/system/run_external.rs (L162-L170)

That is: if user input dynamic things(like variables, sub-expression, or
string interpolation), it returns a quoted `NuPath`, then user input
won't be globbed
 
# User-Facing Changes
Given two input files: `a*c.txt`, `abc.txt`

* `let f = "a*c.txt"; rm $f` will remove one file: `a*c.txt`. 
~* `let f = "a*c.txt"; rm --glob $f` will remove `a*c.txt` and
`abc.txt`~
* `let f: glob = "a*c.txt"; rm $f` will remove `a*c.txt` and `abc.txt`

## Rules about globbing with *variable*
Given two files: `a*c.txt`, `abc.txt`
| Cmd Type | example | Result |
| ----- | ------------------ | ------ |
| builtin | let f = "a*c.txt"; rm $f | remove `a*c.txt` |
| builtin | let f: glob = "a*c.txt"; rm $f | remove `a*c.txt` and
`abc.txt`
| builtin | let f = "a*c.txt"; rm ($f \| into glob) | remove `a*c.txt`
and `abc.txt`
| custom | def crm [f: glob] { rm $f }; let f = "a*c.txt"; crm $f |
remove `a*c.txt` and `abc.txt`
| custom | def crm [f: glob] { rm ($f \| into string) }; let f =
"a*c.txt"; crm $f | remove `a*c.txt`
| custom | def crm [f: string] { rm $f }; let f = "a*c.txt"; crm $f |
remove `a*c.txt`
| custom | def crm [f: string] { rm $f }; let f = "a*c.txt"; crm ($f \|
into glob) | remove `a*c.txt` and `abc.txt`

In general, if a variable is annotated with `glob` type, nushell will
expand glob pattern. Or else, we need to use `into | glob` to expand
glob pattern

# Tests + Formatting
Done

# After Submitting
I think `str glob-escape` command will be no-longer required. We can
remove it.

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

@@ -1,4 +1,12 @@
 use dialoguer::Input;
+use nu_engine::eval_expression;
+use nu_protocol::ast::Expr;
+use nu_protocol::{
+    ast::Call,
+    engine::{EngineState, Stack},
+    ShellError, Spanned, Value,
+};
+use nu_protocol::{FromValue, NuGlob, Type};
 use std::error::Error;
 use std::path::{Path, PathBuf};
 
@@ -200,3 +208,74 @@ pub mod users {
         }
     }
 }
+
+/// Get rest arguments from given `call`, starts with `starting_pos`.
+///
+/// It's similar to `call.rest`, except that it always returns NuGlob.  And if input argument has
+/// Type::Glob, the NuGlob is unquoted, which means it's required to expand.
+pub fn get_rest_for_glob_pattern(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    starting_pos: usize,
+) -> Result<Vec<Spanned<NuGlob>>, ShellError> {
+    let mut output = vec![];
+
+    for result in call.rest_iter_flattened(starting_pos, |expr| {
+        let result = eval_expression(engine_state, stack, expr);
+        match result {
+            Err(e) => Err(e),
+            Ok(result) => {
+                let span = result.span();
+                // convert from string to quoted string if expr is a variable
+                // or string interpolation
+                match result {
+                    Value::String { val, .. }
+                        if matches!(
+                            &expr.expr,
+                            Expr::FullCellPath(_) | Expr::StringInterpolation(_)
+                        ) =>
+                    {
+                        // should not expand if given input type is not glob.
+                        Ok(Value::glob(val, expr.ty != Type::Glob, span))
+                    }
+                    other => Ok(other),
+                }
+            }
+        }
+    })? {
+        output.push(FromValue::from_value(result)?);
+    }
+
+    Ok(output)
+}
+
+/// Get optional arguments from given `call` with position `pos`.
+///
+/// It's similar to `call.opt`, except that it always returns NuGlob.
+pub fn opt_for_glob_pattern(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+    pos: usize,
+) -> Result<Option<Spanned<NuGlob>>, ShellError> {
+    if let Some(expr) = call.positional_nth(pos) {
+        let result = eval_expression(engine_state, stack, expr)?;
+        let result_span = result.span();
+        let result = match result {
+            Value::String { val, .. }
+                if matches!(
+                    &expr.expr,
+                    Expr::FullCellPath(_) | Expr::StringInterpolation(_)
+                ) =>
+            {
+                // should quote if given input type is not glob.
+                Value::glob(val, expr.ty != Type::Glob, result_span)
+            }
+            other => other,
+        };
+        FromValue::from_value(result).map(Some)
+    } else {
+        Ok(None)
+    }
+}