Custom command attributes (#14906)

# Description
Add custom command attributes.

- Attributes are placed before a command definition and start with a `@`
character.
- Attribute invocations consist of const command call. The command's
name must start with "attr ", but this prefix is not used in the
invocation.
- A command named `attr example` is invoked as an attribute as
`@example`
-   Several built-in attribute commands are provided as part of this PR
    -   `attr example`: Attaches an example to the commands help text
        ```nushell
        # Double numbers
        @example "double an int"  { 5 | double }   --result 10
        @example "double a float" { 0.5 | double } --result 1.0
        def double []: [number -> number] {
            $in * 2
        }
        ```
    -   `attr search-terms`: Adds search terms to a command
    -   ~`attr env`: Equivalent to using `def --env`~
- ~`attr wrapped`: Equivalent to using `def --wrapped`~ shelved for
later discussion
    -   several testing related attributes in `std/testing`
- If an attribute has no internal/special purpose, it's stored as
command metadata that can be obtained with `scope commands`.
- This allows having attributes like `@test` which can be used by test
runners.
-   Used the `@example` attribute for `std` examples.
-   Updated the std tests and test runner to use `@test` attributes
-   Added completions for attributes

# User-Facing Changes
Users can add examples to their own command definitions, and add other
arbitrary attributes.

# Tests + Formatting

- 🟢 toolkit fmt
- 🟢 toolkit clippy
- 🟢 toolkit test
- 🟢 toolkit test stdlib

# After Submitting
- Add documentation about the attribute syntax and built-in attributes
- `help attributes`

---------

Co-authored-by: 132ikl <132@ikl.sh>

crates/nu-std/tests/test_std_formats.nu

@@ -1,4 +1,5 @@
 # Test std/formats when importing `use std *`
+use std/testing *
 use std *
 
 def test_data_multiline [--nuon] {
@@ -30,113 +31,113 @@ def test_data_multiline [--nuon] {
   }
 }
 
-#[test]
+@test
 def from_ndjson_multiple_objects [] {
   let result = test_data_multiline | formats from ndjson
   let expect = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}]
   assert equal $result $expect "could not convert from NDJSON"
 }
 
-#[test]
+@test
 def from_ndjson_single_object [] {
   let result = '{"a": 1}' | formats from ndjson
   let expect = [{a:1}]
   assert equal $result $expect "could not convert from NDJSON"
 }
 
-#[test]
+@test
 def from_ndjson_invalid_object [] {
   assert error { '{"a":1' | formats from ndjson }
 }
 
-#[test]
+@test
 def from_jsonl_multiple_objects [] {
   let result = test_data_multiline | formats from jsonl
   let expect = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}]
   assert equal $result $expect "could not convert from JSONL"
 }
 
-#[test]
+@test
 def from_jsonl_single_object [] {
   let result = '{"a": 1}' | formats from jsonl
   let expect = [{a:1}]
   assert equal $result $expect "could not convert from JSONL"
 }
 
-#[test]
+@test
 def from_jsonl_invalid_object [] {
   assert error { '{"a":1' | formats from jsonl }
 }
 
-#[test]
+@test
 def to_ndjson_multiple_objects [] {
   let result = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}] | formats to ndjson | str trim
   let expect = test_data_multiline
   assert equal $result $expect "could not convert to NDJSON"
 }
 
-#[test]
+@test
 def to_ndjson_single_object [] {
   let result = [{a:1}] | formats to ndjson | str trim
   let expect = "{\"a\":1}"
   assert equal $result $expect "could not convert to NDJSON"
 }
 
-#[test]
+@test
 def to_jsonl_multiple_objects [] {
   let result = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}] | formats to jsonl | str trim
   let expect = test_data_multiline
   assert equal $result $expect "could not convert to JSONL"
 }
 
-#[test]
+@test
 def to_jsonl_single_object [] {
   let result = [{a:1}] | formats to jsonl | str trim
   let expect = "{\"a\":1}"
   assert equal $result $expect "could not convert to JSONL"
 }
 
-#[test]
+@test
 def from_ndnuon_multiple_objects [] {
   let result = test_data_multiline | formats from ndnuon
   let expect = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}]
   assert equal $result $expect "could not convert from NDNUON"
 }
 
-#[test]
+@test
 def from_ndnuon_single_object [] {
   let result = '{a: 1}' | formats from ndnuon
   let expect = [{a:1}]
   assert equal $result $expect "could not convert from NDNUON"
 }
 
-#[test]
+@test
 def from_ndnuon_invalid_object [] {
   assert error { '{"a":1' | formats from ndnuon }
 }
 
-#[test]
+@test
 def to_ndnuon_multiple_objects [] {
   let result = [{a:1},{a:2},{a:3},{a:4},{a:5},{a:6}] | formats to ndnuon | str trim
   let expect = test_data_multiline --nuon
   assert equal $result $expect "could not convert to NDNUON"
 }
 
-#[test]
+@test
 def to_ndnuon_single_object [] {
   let result = [{a:1}] | formats to ndnuon | str trim
   let expect = "{a: 1}"
   assert equal $result $expect "could not convert to NDNUON"
 }
 
-#[test]
+@test
 def to_ndnuon_multiline_strings [] {
   let result = "foo\n\\n\nbar" | formats to ndnuon
   let expect = '"foo\n\\n\nbar"'
   assert equal $result $expect "could not convert multiline string to NDNUON"
 }
 
-#[test]
+@test
 def from_ndnuon_multiline_strings [] {
   let result = '"foo\n\\n\nbar"' | formats from ndnuon
   let expect = ["foo\n\\n\nbar"]