Split the plugin crate (#12563)

# Description

This breaks `nu-plugin` up into four crates:

- `nu-plugin-protocol`: just the type definitions for the protocol, no
I/O. If someone wanted to wire up something more bare metal, maybe for
async I/O, they could use this.
- `nu-plugin-core`: the shared stuff between engine/plugin. Less stable
interface.
- `nu-plugin-engine`: everything required for the engine to talk to
plugins. Less stable interface.
- `nu-plugin`: everything required for the plugin to talk to the engine,
what plugin developers use. Should be the most stable interface.

No changes are made to the interface exposed by `nu-plugin` - it should
all still be there. Re-exports from `nu-plugin-protocol` or
`nu-plugin-core` are used as required. Plugins shouldn't ever have to
use those crates directly.

This should be somewhat faster to compile as `nu-plugin-engine` and
`nu-plugin` can compile in parallel, and the engine doesn't need
`nu-plugin` and plugins don't need `nu-plugin-engine` (except for test
support), so that should reduce what needs to be compiled too.

The only significant change here other than splitting stuff up was to
break the `source` out of `PluginCustomValue` and create a new
`PluginCustomValueWithSource` type that contains that instead. One bonus
of that is we get rid of the option and it's now more type-safe, but it
also means that the logic for that stuff (actually running the plugin
for custom value ops) can live entirely within the `nu-plugin-engine`
crate.

# User-Facing Changes
- New crates.
- Added `local-socket` feature for `nu` to try to make it possible to
compile without that support if needed.

# Tests + Formatting
- 🟢 `toolkit fmt`
- 🟢 `toolkit clippy`
- 🟢 `toolkit test`
- 🟢 `toolkit test stdlib`

crates/nu-plugin-engine/src/util/mod.rs

@@ -0,0 +1,3 @@
+mod mutable_cow;
+
+pub use mutable_cow::MutableCow;

crates/nu-plugin-engine/src/util/mutable_cow.rs

@@ -0,0 +1,35 @@
+/// Like [`Cow`] but with a mutable reference instead. So not exactly clone-on-write, but can be
+/// made owned.
+pub enum MutableCow<'a, T> {
+    Borrowed(&'a mut T),
+    Owned(T),
+}
+
+impl<'a, T: Clone> MutableCow<'a, T> {
+    pub fn owned(&self) -> MutableCow<'static, T> {
+        match self {
+            MutableCow::Borrowed(r) => MutableCow::Owned((*r).clone()),
+            MutableCow::Owned(o) => MutableCow::Owned(o.clone()),
+        }
+    }
+}
+
+impl<'a, T> std::ops::Deref for MutableCow<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        match self {
+            MutableCow::Borrowed(r) => r,
+            MutableCow::Owned(o) => o,
+        }
+    }
+}
+
+impl<'a, T> std::ops::DerefMut for MutableCow<'a, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        match self {
+            MutableCow::Borrowed(r) => r,
+            MutableCow::Owned(o) => o,
+        }
+    }
+}