Allow plugins to report their own version and store it in the registry (#12883)

# Description

This allows plugins to report their version (and potentially other
metadata in the future). The version is shown in `plugin list` and in
`version`.

The metadata is stored in the registry file, and reflects whatever was
retrieved on `plugin add`, not necessarily the running binary. This can
help you to diagnose if there's some kind of mismatch with what you
expect. We could potentially use this functionality to show a warning or
error if a plugin being run does not have the same version as what was
in the cache file, suggesting `plugin add` be run again, but I haven't
done that at this point.

It is optional, and it requires the plugin author to make some code
changes if they want to provide it, since I can't automatically
determine the version of the calling crate or anything tricky like that
to do it.

Example:

```
> plugin list | select name version is_running pid
╭───┬────────────────┬─────────┬────────────┬─────╮
│ # │      name      │ version │ is_running │ pid │
├───┼────────────────┼─────────┼────────────┼─────┤
│ 0 │ example        │ 0.93.1  │ false      │     │
│ 1 │ gstat          │ 0.93.1  │ false      │     │
│ 2 │ inc            │ 0.93.1  │ false      │     │
│ 3 │ python_example │ 0.1.0   │ false      │     │
╰───┴────────────────┴─────────┴────────────┴─────╯
```

cc @maxim-uvarov (he asked for it)

# User-Facing Changes

- `plugin list` gets a `version` column
- `version` shows plugin versions when available
- plugin authors *should* add `fn metadata()` to their `impl Plugin`,
but don't have to

# Tests + Formatting

Tested the low level stuff and also the `plugin list` column.

# After Submitting
- [ ] update plugin guide docs
- [ ] update plugin protocol docs (`Metadata` call & response)
- [ ] update plugin template (`fn metadata()` should be easy)
- [ ] release notes

crates/nu-parser/src/parse_keywords.rs

@@ -3740,28 +3740,37 @@ pub fn parse_register(working_set: &mut StateWorkingSet, lite_command: &LiteComm
                     )
                 })?;
 
-                let signatures = plugin
+                let metadata_and_signatures = plugin
                     .clone()
                     .get(get_envs)
-                    .and_then(|p| p.get_signature())
+                    .and_then(|p| {
+                        let meta = p.get_metadata()?;
+                        let sigs = p.get_signature()?;
+                        Ok((meta, sigs))
+                    })
                     .map_err(|err| {
-                        log::warn!("Error getting signatures: {err:?}");
+                        log::warn!("Error getting metadata and signatures: {err:?}");
                         ParseError::LabeledError(
-                            "Error getting signatures".into(),
+                            "Error getting metadata and signatures".into(),
                             err.to_string(),
                             spans[0],
                         )
                     });
 
-                if let Ok(ref signatures) = signatures {
-                    // Add the loaded plugin to the delta
-                    working_set.update_plugin_registry(PluginRegistryItem::new(
-                        &identity,
-                        signatures.clone(),
-                    ));
+                match metadata_and_signatures {
+                    Ok((meta, sigs)) => {
+                        // Set the metadata on the plugin
+                        plugin.set_metadata(Some(meta.clone()));
+                        // Add the loaded plugin to the delta
+                        working_set.update_plugin_registry(PluginRegistryItem::new(
+                            &identity,
+                            meta,
+                            sigs.clone(),
+                        ));
+                        Ok(sigs)
+                    }
+                    Err(err) => Err(err),
                 }
-
-                signatures
             },
             |sig| sig.map(|sig| vec![sig]),
         )?;