Box ShellError in Value::Error (#8375)

# Description

Our `ShellError` at the moment has a `std::mem::size_of<ShellError>` of
136 bytes (on AMD64). As a result `Value` directly storing the struct
also required 136 bytes (thanks to alignment requirements).

This change stores the `Value::Error` `ShellError` on the heap.

Pro:
- Value now needs just 80 bytes
- Should be 1 cacheline less (still at least 2 cachelines)

Con:
- More small heap allocations when dealing with `Value::Error`
  - More heap fragmentation
  - Potential for additional required memcopies

# Further code changes

Includes a small refactor of `try` due to a type mismatch in its large
match.

# User-Facing Changes

None for regular users.

Plugin authors may have to update their matches on `Value` if they use
`nu-protocol`

Needs benchmarking to see if there is a benefit in real world workloads.
**Update** small improvements in runtime for workloads with high volume
of values. Significant reduction in maximum resident set size, when many
values are held in memory.

# Tests + Formatting

crates/nu-command/src/bytes/at.rs

@@ -41,7 +41,7 @@ fn parse_range(range: Value, head: Span) -> Result<(isize, isize, Span), ShellEr
                     Value::Int { val, .. } => val.to_string(),
                     Value::String { val, .. } => val,
                     // Explicitly propagate errors instead of dropping them.
-                    Value::Error { error } => return Err(error),
+                    Value::Error { error } => return Err(*error),
                     other => {
                         return Err(ShellError::UnsupportedInput(
                             "Only string or list<int> ranges are supported".into(),
@@ -56,7 +56,7 @@ fn parse_range(range: Value, head: Span) -> Result<(isize, isize, Span), ShellEr
                     Value::Int { val, .. } => val.to_string(),
                     Value::String { val, .. } => val,
                     // Explicitly propagate errors instead of dropping them.
-                    Value::Error { error } => return Err(error),
+                    Value::Error { error } => return Err(*error),
                     other => {
                         return Err(ShellError::UnsupportedInput(
                             "Only string or list<int> ranges are supported".into(),
@@ -84,7 +84,7 @@ fn parse_range(range: Value, head: Span) -> Result<(isize, isize, Span), ShellEr
             }
         }
         // Explicitly propagate errors instead of dropping them.
-        Value::Error { error } => return Err(error),
+        Value::Error { error } => return Err(*error),
         other => {
             return Err(ShellError::UnsupportedInput(
                 "could not perform subbytes".to_string(),
@@ -249,12 +249,12 @@ fn at(val: &Value, args: &Arguments, span: Span) -> Value {
         // Propagate errors by explicitly matching them before the final case.
         Value::Error { .. } => val.clone(),
         other => Value::Error {
-            error: ShellError::OnlySupportsThisInputType {
+            error: Box::new(ShellError::OnlySupportsThisInputType {
                 exp_input_type: "binary".into(),
                 wrong_type: other.get_type().to_string(),
                 dst_span: span,
                 src_span: other.expect_span(),
-            },
+            }),
         },
     }
 }
@@ -277,10 +277,10 @@ fn at_impl(input: &[u8], arg: &Arguments, span: Span) -> Value {
         match start.cmp(&end) {
             Ordering::Equal => Value::Binary { val: vec![], span },
             Ordering::Greater => Value::Error {
-                error: ShellError::TypeMismatch {
+                error: Box::new(ShellError::TypeMismatch {
                     err_message: "End must be greater than or equal to Start".to_string(),
                     span: arg.arg_span,
-                },
+                }),
             },
             Ordering::Less => Value::Binary {
                 val: {