Avoid blocking when o+e> redirects too much stderr message (#8784)

# Description

Fixes: #8565

Here is another pr #7240 tried to address the issue, but it works in a
wrong way.

After this change `o+e>` won't redirect all stdout message then stderr
message and it works more like how bash does.

# User-Facing Changes

For the given python code:
```python
# test.py
import sys

print('aa'*300, flush=True)
print('bb'*999999, file=sys.stderr, flush=True)
print('cc'*300, flush=True)
```

Running `python test.py out+err> a.txt` shoudn't hang nushell, and
`a.txt` keeps output in the same order

## About the change
The core idea is that when doing lite-parsing, introduce a new variant
`LiteElement::SameTargetRedirection` if we meet `out+err>` redirection
token(which is generated by lex function),

During converting from lite block to block,
LiteElement::SameTargetRedirection will be converted to
PipelineElement::SameTargetRedirection.

Then in the block eval process, if we get
PipelineElement::SameTargetRedirection, we'll invoke `run-external` with
`--redirect-combine` flag, then pipe the result into save command

## What happened internally?

Take the following command as example:
`^ls o+e> log.txt`

lex parsing result(`Tokens`) are not changed, but `LiteBlock` and
`Block` is changed after this pr.
### LiteBlock before
```rust
LiteBlock {
    block: [
        LitePipeline { commands: [
            Command(None, LiteCommand { comments: [], parts: [Span { start: 39041, end: 39044 }] }),
            // actually the span of first Redirection is wrong too..
            Redirection(Span { start: 39058, end: 39062 }, StdoutAndStderr, LiteCommand { comments: [], parts: [Span { start: 39050, end: 39057 }] }),
        ]
    }]
}
```
### LiteBlock after
```rust
LiteBlock { 
    block: [
        LitePipeline {
            commands: [
                SameTargetRedirection {
                    cmd: (None, LiteCommand { comments: [], parts: [Span { start: 147945, end: 147948}]}),
                    redirection: (Span { start: 147949, end: 147957 }, LiteCommand { comments: [], parts: [Span { start: 147958, end: 147965 }]})
                }
            ]
        }
    ]
}
```
### Block before
```rust
Pipeline {
    elements: [
        Expression(None, Expression {
            expr: ExternalCall(Expression { expr: String("ls"), span: Span { start: 39042, end: 39044 }, ty: String, custom_completion: None }, [], false),
            span: Span { start: 39041, end: 39044 },
            ty: Any, custom_completion: None 
        }),
        Redirection(Span { start: 39058, end: 39062 }, StdoutAndStderr, Expression { expr: String("out.txt"), span: Span { start: 39050, end: 39057 }, ty: String, custom_completion: None })] }
```
### Block after
```rust
Pipeline {
    elements: [
        SameTargetRedirection { 
            cmd: (None, Expression {
                expr: ExternalCall(Expression { expr: String("ls"), span: Span { start: 147946, end: 147948 }, ty: String, custom_completion: None}, [], false),
                span: Span { start: 147945, end: 147948},
                ty: Any, custom_completion: None
            }),
            redirection: (Span { start: 147949, end: 147957}, Expression {expr: String("log.txt"), span: Span { start: 147958, end: 147965 },ty: String,custom_completion: None}
        }
    ]
}
```

# 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
- `cargo run -- crates/nu-utils/standard_library/tests.nu` to run the
tests for the standard library

> **Note**
> from `nushell` you can also use the `toolkit` as follows
> ```bash
> use toolkit.nu # or use an `env_change` hook to activate it
automatically
> toolkit check pr
> ```

# 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/lite_parser.rs

@@ -43,6 +43,11 @@ pub enum LiteElement {
         out: (Span, LiteCommand),
         err: (Span, LiteCommand),
     },
+    // SameTargetRedirection variant can only be generated by Command with Redirection::OutAndErr
+    SameTargetRedirection {
+        cmd: (Option<Span>, LiteCommand),
+        redirection: (Span, LiteCommand),
+    },
 }
 
 #[derive(Debug)]
@@ -95,6 +100,7 @@ impl LiteBlock {
         // the block takes ownership of `pipeline`, which means that
         // our `pipeline` is complete on collecting commands.
         self.merge_redirections(&mut pipeline);
+        self.merge_cmd_with_outerr_redirection(&mut pipeline);
 
         self.block.push(pipeline);
     }
@@ -103,6 +109,40 @@ impl LiteBlock {
         self.block.is_empty()
     }
 
+    fn merge_cmd_with_outerr_redirection(&self, pipeline: &mut LitePipeline) {
+        let mut cmd_index = None;
+        let mut outerr_index = None;
+        for (index, cmd) in pipeline.commands.iter().enumerate() {
+            if let LiteElement::Command(..) = cmd {
+                cmd_index = Some(index);
+            }
+            if let LiteElement::Redirection(_span, Redirection::StdoutAndStderr, _target_cmd) = cmd
+            {
+                outerr_index = Some(index);
+                break;
+            }
+        }
+        if let (Some(cmd_index), Some(outerr_index)) = (cmd_index, outerr_index) {
+            // we can make sure that cmd_index is less than outerr_index.
+            let outerr_redirect = pipeline.commands.remove(outerr_index);
+            let cmd = pipeline.commands.remove(cmd_index);
+            // `outerr_redirect` and `cmd` should always be `LiteElement::Command` and `LiteElement::Redirection`
+            if let (
+                LiteElement::Command(cmd_span, lite_cmd),
+                LiteElement::Redirection(span, _, outerr_cmd),
+            ) = (cmd, outerr_redirect)
+            {
+                pipeline.insert(
+                    cmd_index,
+                    LiteElement::SameTargetRedirection {
+                        cmd: (cmd_span, lite_cmd),
+                        redirection: (span, outerr_cmd),
+                    },
+                )
+            }
+        }
+    }
+
     fn merge_redirections(&self, pipeline: &mut LitePipeline) {
         // In case our command may contains both stdout and stderr redirection.
         // We pick them out and Combine them into one LiteElement::SeparateRedirection variant.