Move most of the peculiar argument handling for external calls into the parser (#13089)

# Description

We've had a lot of different issues and PRs related to arg handling with
externals since the rewrite of `run-external` in #12921:

- #12950
- #12955
- #13000
- #13001
- #13021
- #13027
- #13028
- #13073

Many of these are caused by the argument handling of external calls and
`run-external` being very special and involving the parser handing
quoted strings over to `run-external` so that it knows whether to expand
tildes and globs and so on. This is really unusual and also makes it
harder to use `run-external`, and also harder to understand it (and
probably is part of the reason why it was rewritten in the first place).

This PR moves a lot more of that work over to the parser, so that by the
time `run-external` gets it, it's dealing with much more normal Nushell
values. In particular:

- Unquoted strings are handled as globs with no expand
- The unescaped-but-quoted handling of strings was removed, and the
parser constructs normal looking strings instead, removing internal
quotes so that `run-external` doesn't have to do it
- Bare word interpolation is now supported and expansion is done in this
case
- Expressions typed as `Glob` containing `Expr::StringInterpolation` now
produce `Value::Glob` instead, with the quoted status from the expr
passed through so we know if it was a bare word
- Bare word interpolation for values typed as `glob` now possible, but
not implemented
- Because expansion is now triggered by `Value::Glob(_, false)` instead
of looking at the expr, externals now support glob types

# User-Facing Changes

- Bare word interpolation works for external command options, and
otherwise embedded in other strings:
  ```nushell
  ^echo --foo=(2 + 2) # prints --foo=4
  ^echo -foo=$"(2 + 2)" # prints -foo=4
  ^echo foo="(2 + 2)" # prints (no interpolation!) foo=(2 + 2)
  ^echo foo,(2 + 2),bar # prints foo,4,bar
  ```

- Bare word interpolation expands for external command head/args:
  ```nushell
  let name = "exa"
  ~/.cargo/bin/($name) # this works, and expands the tilde
  ^$"~/.cargo/bin/($name)" # this doesn't expand the tilde
  ^echo ~/($name)/* # this glob is expanded
  ^echo $"~/($name)/*" # this isn't expanded
  ```

- Ndots are now supported for the head of an external command
(`^.../foo` works)

- Glob values are now supported for head/args of an external command,
and expanded appropriately:
  ```nushell
  ^("~/.cargo/bin/exa" | into glob) # the tilde is expanded
  ^echo ("*.txt" | into glob) # this glob is expanded
  ```

- `run-external` now works more like any other command, without
expecting a special call convention
  for its args:
  ```nushell
  run-external echo "'foo'"
  # before PR: 'foo'
  # after PR:  foo
  run-external echo "*.txt"
  # before PR: (glob is expanded)
  # after PR:  *.txt
  ```

# Tests + Formatting
Lots of tests added and cleaned up. Some tests that weren't active on
Windows changed to use `nu --testbin cococo` so that they can work.
Added a test for Linux only to make sure tilde expansion of commands
works, because changing `HOME` there causes `~` to reliably change.

- 🟢 `toolkit fmt`
- 🟢 `toolkit clippy`
- 🟢 `toolkit test`
- 🟢 `toolkit test stdlib`

# After Submitting
- [ ] release notes: make sure to mention the new syntaxes that are
supported

crates/nu-protocol/src/ast/expr.rs

@@ -32,8 +32,11 @@ pub enum Expr {
     Keyword(Box<Keyword>),
     ValueWithUnit(Box<ValueWithUnit>),
     DateTime(chrono::DateTime<FixedOffset>),
+    /// The boolean is `true` if the string is quoted.
     Filepath(String, bool),
+    /// The boolean is `true` if the string is quoted.
     Directory(String, bool),
+    /// The boolean is `true` if the string is quoted.
     GlobPattern(String, bool),
     String(String),
     RawString(String),
@@ -43,6 +46,8 @@ pub enum Expr {
     Overlay(Option<BlockId>), // block ID of the overlay's origin module
     Signature(Box<Signature>),
     StringInterpolation(Vec<Expression>),
+    /// The boolean is `true` if the string is quoted.
+    GlobInterpolation(Vec<Expression>, bool),
     Nothing,
     Garbage,
 }
@@ -84,6 +89,7 @@ impl Expr {
             | Expr::RawString(_)
             | Expr::CellPath(_)
             | Expr::StringInterpolation(_)
+            | Expr::GlobInterpolation(_, _)
             | Expr::Nothing => {
                 // These expressions do not use the output of the pipeline in any meaningful way,
                 // so we can discard the previous output by redirecting it to `Null`.

crates/nu-protocol/src/ast/expression.rs

@@ -232,7 +232,7 @@ impl Expression {
                 }
                 false
             }
-            Expr::StringInterpolation(items) => {
+            Expr::StringInterpolation(items) | Expr::GlobInterpolation(items, _) => {
                 for i in items {
                     if i.has_in_variable(working_set) {
                         return true;
@@ -441,7 +441,7 @@ impl Expression {
             Expr::Signature(_) => {}
             Expr::String(_) => {}
             Expr::RawString(_) => {}
-            Expr::StringInterpolation(items) => {
+            Expr::StringInterpolation(items) | Expr::GlobInterpolation(items, _) => {
                 for i in items {
                     i.replace_span(working_set, replaced, new_span)
                 }

crates/nu-protocol/src/debugger/profiler.rs

@@ -258,6 +258,7 @@ fn expr_to_string(engine_state: &EngineState, expr: &Expr) -> String {
         Expr::Signature(_) => "signature".to_string(),
         Expr::String(_) | Expr::RawString(_) => "string".to_string(),
         Expr::StringInterpolation(_) => "string interpolation".to_string(),
+        Expr::GlobInterpolation(_, _) => "glob interpolation".to_string(),
         Expr::Subexpression(_) => "subexpression".to_string(),
         Expr::Table(_) => "table".to_string(),
         Expr::UnaryNot(_) => "unary not".to_string(),

crates/nu-protocol/src/eval_base.rs

@@ -290,6 +290,15 @@ pub trait Eval {
 
                 Ok(Value::string(str, expr_span))
             }
+            Expr::GlobInterpolation(exprs, quoted) => {
+                let config = Self::get_config(state, mut_state);
+                let str = exprs
+                    .iter()
+                    .map(|expr| Self::eval::<D>(state, mut_state, expr).map(|v| v.to_expanded_string(", ", &config)))
+                    .collect::<Result<String, _>>()?;
+
+                Ok(Value::glob(str, *quoted, expr_span))
+            }
             Expr::Overlay(_) => Self::eval_overlay(state, expr_span),
             Expr::GlobPattern(pattern, quoted) => {
                 // GlobPattern is similar to Filepath