Rework operator type errors (#14429)

# Description

This PR adds two new `ParseError` and `ShellError` cases for type errors
relating to operators.
- `OperatorUnsupportedType` is used when a type is not supported by an
operator in any way, shape, or form. E.g., `+` does not support `bool`.
- `OperatorIncompatibleTypes` is used when a operator is used with types
it supports, but the combination of types provided cannot be used
together. E.g., `filesize + duration` is not a valid combination.

The other preexisting error cases related to operators have been removed
and replaced with the new ones above. Namely:

- `ShellError::OperatorMismatch`
- `ShellError::UnsupportedOperator`
- `ParseError::UnsupportedOperationLHS`
- `ParseError::UnsupportedOperationRHS`
- `ParseError::UnsupportedOperationTernary`

# User-Facing Changes

- `help operators` now lists the precedence of `not` as 55 instead of 0
(above the other boolean operators). Fixes #13675.
- `math median` and `math mode` now ignore NaN values so that `[NaN NaN]
| math median` and `[NaN NaN] | math mode` no longer trigger a type
error. Instead, it's now an empty input error. Fixing this in earnest
can be left for a future PR.
- Comparisons with `nan` now return false instead of causing an error.
E.g., `1 == nan` is now `false`.
- All the operator type errors have been standardized and reworked. In
particular, they can now have a help message, which is currently used
for types errors relating to `++`.

```nu
[1] ++ 2
```
```
Error: nu::parser::operator_unsupported_type

  × The '++' operator does not work on values of type 'int'.
   ╭─[entry #1:1:5]
 1 │ [1] ++ 2
   ·     ─┬ ┬
   ·      │ ╰── int
   ·      ╰── does not support 'int'
   ╰────
  help: if you meant to append a value to a list or a record to a table, use the `append` command or wrap the value in a list. For example: `$list ++ $value` should be
        `$list ++ [$value]` or `$list | append $value`.
```

crates/nu-protocol/src/value/custom_value.rs

@@ -1,6 +1,6 @@
 use std::{cmp::Ordering, fmt};
 
-use crate::{ast::Operator, ShellError, Span, Value};
+use crate::{ast::Operator, ShellError, Span, Type, Value};
 
 /// Trait definition for a custom [`Value`](crate::Value) type
 #[typetag::serde(tag = "type")]
@@ -68,7 +68,7 @@ pub trait CustomValue: fmt::Debug + Send + Sync {
     ///
     /// The Operator enum is used to indicate the expected operation.
     ///
-    /// Default impl raises [`ShellError::UnsupportedOperator`].
+    /// Default impl raises [`ShellError::OperatorUnsupportedType`].
     fn operation(
         &self,
         lhs_span: Span,
@@ -77,7 +77,13 @@ pub trait CustomValue: fmt::Debug + Send + Sync {
         right: &Value,
     ) -> Result<Value, ShellError> {
         let _ = (lhs_span, right);
-        Err(ShellError::UnsupportedOperator { operator, span: op })
+        Err(ShellError::OperatorUnsupportedType {
+            op: operator,
+            unsupported: Type::Custom(self.type_name().into()),
+            op_span: op,
+            unsupported_span: lhs_span,
+            help: None,
+        })
     }
 
     /// For custom values in plugins: return `true` here if you would like to be notified when all