Better errors when bash-like operators are used (#7241)

# Description

Adds improved errors for when a user uses a bashism that nu doesn't
support.

fixes #7237 

Examples:

```
Error: nu::parser::shell_andand (link)

  × The '&&' operator is not supported in Nushell
   ╭─[entry #1:1:1]
 1 │ ls && ls
   ·    ─┬
   ·     ╰── instead of '&&', use ';' or 'and'
   ╰────
  help: use ';' instead of the shell '&&', or 'and' instead of the boolean '&&'
```

```
Error: nu::parser::shell_oror (link)

  × The '||' operator is not supported in Nushell
   ╭─[entry #8:1:1]
 1 │ ls || ls
   ·    ─┬
   ·     ╰── instead of '||', use 'try' or 'or'
   ╰────
  help: use 'try' instead of the shell '||', or 'or' instead of the boolean '||'
```

```
Error: nu::parser::shell_err (link)

  × The '2>' shell operation is 'err>' in Nushell.
   ╭─[entry #9:1:1]
 1 │ foo 2> bar.txt
   ·     ─┬
   ·      ╰── use 'err>' instead of '2>' in Nushell
   ╰────
```

```
Error: nu::parser::shell_outerr (link)

  × The '2>&1' shell operation is 'out+err>' in Nushell.
   ╭─[entry #10:1:1]
 1 │ foo 2>&1 bar.txt
   ·     ──┬─
   ·       ╰── use 'out+err>' instead of '2>&1' in Nushell
   ╰────
  help: Nushell redirection will write all of stdout before stderr.
```


# User-Facing Changes

**BREAKING CHANGES**

This removes the `&&` and `||` operators. We previously supported by
`&&`/`and` and `||`/`or`. With this change, only `and` and `or` are
valid boolean operators.

# Tests + Formatting

Don't forget to add tests that cover your changes.

Make sure you've run and fixed any issues with these commands:

- `cargo fmt --all -- --check` to check standard code formatting (`cargo
fmt --all` applies these changes)
- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A
clippy::needless_collect` to check that you're using the standard code
style
- `cargo test --workspace` to check that all tests pass

# After Submitting

If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.

crates/nu-parser/src/parser.rs

@@ -1212,18 +1212,17 @@ fn parse_binary_with_base(
 
                         binary_value.extend_from_slice(contents);
                     }
-                    TokenContents::Pipe => {
+                    TokenContents::Pipe
+                    | TokenContents::PipePipe
+                    | TokenContents::OutGreaterThan
+                    | TokenContents::ErrGreaterThan
+                    | TokenContents::OutErrGreaterThan => {
                         return (
                             garbage(span),
                             Some(ParseError::Expected("binary".into(), span)),
                         );
                     }
-                    TokenContents::Comment
-                    | TokenContents::Semicolon
-                    | TokenContents::Eol
-                    | TokenContents::OutGreaterThan
-                    | TokenContents::ErrGreaterThan
-                    | TokenContents::OutErrGreaterThan => {}
+                    TokenContents::Comment | TokenContents::Semicolon | TokenContents::Eol => {}
                 }
             }
 
@@ -4075,19 +4074,12 @@ pub fn parse_closure_expression(
             (Some((signature, signature_span)), amt_to_skip)
         }
         Some(Token {
-            contents: TokenContents::Item,
+            contents: TokenContents::PipePipe,
             span,
-        }) => {
-            let contents = working_set.get_span_contents(*span);
-            if contents == b"||" {
-                (
-                    Some((Box::new(Signature::new("closure".to_string())), *span)),
-                    1,
-                )
-            } else {
-                (None, 0)
-            }
-        }
+        }) => (
+            Some((Box::new(Signature::new("closure".to_string())), *span)),
+            1,
+        ),
         _ => (None, 0),
     };
 
@@ -4456,8 +4448,8 @@ pub fn parse_operator(
         b"bit-shr" => Operator::Bits(Bits::ShiftRight),
         b"starts-with" => Operator::Comparison(Comparison::StartsWith),
         b"ends-with" => Operator::Comparison(Comparison::EndsWith),
-        b"&&" | b"and" => Operator::Boolean(Boolean::And),
-        b"||" | b"or" => Operator::Boolean(Boolean::Or),
+        b"and" => Operator::Boolean(Boolean::And),
+        b"or" => Operator::Boolean(Boolean::Or),
         b"xor" => Operator::Boolean(Boolean::Xor),
         b"**" => Operator::Math(Math::Pow),
         // WARNING: not actual operators below! Error handling only
@@ -5916,8 +5908,15 @@ pub fn lite_parse(tokens: &[Token]) -> (LiteBlock, Option<ParseError>) {
 
     let mut curr_comment: Option<Vec<Span>> = None;
 
+    let mut error = None;
+
     for token in tokens.iter() {
         match &token.contents {
+            TokenContents::PipePipe => {
+                error = error.or(Some(ParseError::ShellOrOr(token.span)));
+                curr_command.push(token.span);
+                last_token = TokenContents::Item;
+            }
             TokenContents::Item => {
                 // If we have a comment, go ahead and attach it
                 if let Some(curr_comment) = curr_comment.take() {
@@ -6163,7 +6162,7 @@ pub fn lite_parse(tokens: &[Token]) -> (LiteBlock, Option<ParseError>) {
             )),
         )
     } else {
-        (block, None)
+        (block, error)
     }
 }