Replace ExternalStream with new ByteStream type (#12774)

# Description
This PR introduces a `ByteStream` type which is a `Read`-able stream of
bytes. Internally, it has an enum over three different byte stream
sources:
```rust
pub enum ByteStreamSource {
    Read(Box<dyn Read + Send + 'static>),
    File(File),
    Child(ChildProcess),
}
```

This is in comparison to the current `RawStream` type, which is an
`Iterator<Item = Vec<u8>>` and has to allocate for each read chunk.

Currently, `PipelineData::ExternalStream` serves a weird dual role where
it is either external command output or a wrapper around `RawStream`.
`ByteStream` makes this distinction more clear (via `ByteStreamSource`)
and replaces `PipelineData::ExternalStream` in this PR:
```rust
pub enum PipelineData {
    Empty,
    Value(Value, Option<PipelineMetadata>),
    ListStream(ListStream, Option<PipelineMetadata>),
    ByteStream(ByteStream, Option<PipelineMetadata>),
}
```

The PR is relatively large, but a decent amount of it is just repetitive
changes.

This PR fixes #7017, fixes #10763, and fixes #12369.

This PR also improves performance when piping external commands. Nushell
should, in most cases, have competitive pipeline throughput compared to,
e.g., bash.
| Command | Before (MB/s) | After (MB/s) | Bash (MB/s) |
| -------------------------------------------------- | -------------:|
------------:| -----------:|
| `throughput \| rg 'x'` | 3059 | 3744 | 3739 |
| `throughput \| nu --testbin relay o> /dev/null` | 3508 | 8087 | 8136 |

# User-Facing Changes
- This is a breaking change for the plugin communication protocol,
because the `ExternalStreamInfo` was replaced with `ByteStreamInfo`.
Plugins now only have to deal with a single input stream, as opposed to
the previous three streams: stdout, stderr, and exit code.
- The output of `describe` has been changed for external/byte streams.
- Temporary breaking change: `bytes starts-with` no longer works with
byte streams. This is to keep the PR smaller, and `bytes ends-with`
already does not work on byte streams.
- If a process core dumped, then instead of having a `Value::Error` in
the `exit_code` column of the output returned from `complete`, it now is
a `Value::Int` with the negation of the signal number.

# After Submitting
- Update docs and book as necessary
- Release notes (e.g., plugin protocol changes)
- Adapt/convert commands to work with byte streams (high priority is
`str length`, `bytes starts-with`, and maybe `bytes ends-with`).
- Refactor the `tee` code, Devyn has already done some work on this.

---------

Co-authored-by: Devyn Cairns <devyn.cairns@gmail.com>

crates/nu-explore/src/nu_common/value.rs

@@ -1,7 +1,7 @@
 use super::NuSpan;
 use anyhow::Result;
 use nu_engine::get_columns;
-use nu_protocol::{record, ListStream, PipelineData, PipelineMetadata, RawStream, Value};
+use nu_protocol::{record, ByteStream, ListStream, PipelineData, PipelineMetadata, Value};
 use std::collections::HashMap;
 
 pub fn collect_pipeline(input: PipelineData) -> Result<(Vec<String>, Vec<Vec<Value>>)> {
@@ -9,16 +9,7 @@ pub fn collect_pipeline(input: PipelineData) -> Result<(Vec<String>, Vec<Vec<Val
         PipelineData::Empty => Ok((vec![], vec![])),
         PipelineData::Value(value, ..) => collect_input(value),
         PipelineData::ListStream(stream, ..) => Ok(collect_list_stream(stream)),
-        PipelineData::ExternalStream {
-            stdout,
-            stderr,
-            exit_code,
-            metadata,
-            span,
-            ..
-        } => Ok(collect_external_stream(
-            stdout, stderr, exit_code, metadata, span,
-        )),
+        PipelineData::ByteStream(stream, metadata) => Ok(collect_byte_stream(stream, metadata)),
     }
 }
 
@@ -42,49 +33,60 @@ fn collect_list_stream(stream: ListStream) -> (Vec<String>, Vec<Vec<Value>>) {
     (cols, data)
 }
 
-fn collect_external_stream(
-    stdout: Option<RawStream>,
-    stderr: Option<RawStream>,
-    exit_code: Option<ListStream>,
+fn collect_byte_stream(
+    stream: ByteStream,
     metadata: Option<PipelineMetadata>,
-    span: NuSpan,
 ) -> (Vec<String>, Vec<Vec<Value>>) {
+    let span = stream.span();
+
     let mut columns = vec![];
     let mut data = vec![];
-    if let Some(stdout) = stdout {
-        let value = stdout.into_string().map_or_else(
-            |error| Value::error(error, span),
-            |string| Value::string(string.item, span),
-        );
 
-        columns.push(String::from("stdout"));
-        data.push(value);
-    }
-    if let Some(stderr) = stderr {
-        let value = stderr.into_string().map_or_else(
-            |error| Value::error(error, span),
-            |string| Value::string(string.item, span),
-        );
+    match stream.into_child() {
+        Ok(child) => match child.wait_with_output() {
+            Ok(output) => {
+                let exit_code = output.exit_status.code();
+                if let Some(stdout) = output.stdout {
+                    columns.push(String::from("stdout"));
+                    data.push(string_or_binary(stdout, span));
+                }
+                if let Some(stderr) = output.stderr {
+                    columns.push(String::from("stderr"));
+                    data.push(string_or_binary(stderr, span));
+                }
+                columns.push(String::from("exit_code"));
+                data.push(Value::int(exit_code.into(), span));
+            }
+            Err(err) => {
+                columns.push("".into());
+                data.push(Value::error(err, span));
+            }
+        },
+        Err(stream) => {
+            let value = stream
+                .into_value()
+                .unwrap_or_else(|err| Value::error(err, span));
 
-        columns.push(String::from("stderr"));
-        data.push(value);
+            columns.push("".into());
+            data.push(value);
+        }
     }
-    if let Some(exit_code) = exit_code {
-        let list = exit_code.into_iter().collect::<Vec<_>>();
-        let val = Value::list(list, span);
 
-        columns.push(String::from("exit_code"));
-        data.push(val);
-    }
     if metadata.is_some() {
         let val = Value::record(record! { "data_source" => Value::string("ls", span) }, span);
-
         columns.push(String::from("metadata"));
         data.push(val);
     }
     (columns, vec![data])
 }
 
+fn string_or_binary(bytes: Vec<u8>, span: NuSpan) -> Value {
+    match String::from_utf8(bytes) {
+        Ok(str) => Value::string(str, span),
+        Err(err) => Value::binary(err.into_bytes(), span),
+    }
+}
+
 /// Try to build column names and a table grid.
 pub fn collect_input(value: Value) -> Result<(Vec<String>, Vec<Vec<Value>>)> {
     let span = value.span();