Rename to url command to url build-query (#7702)

# Description

Refactor command: "to url" in: "to url query". Changed usage sentence.
Closes: #7495

# User-Facing Changes

Now we get a query string from a record or table by using command: "to
url query".

```
> help to url query
Convert record or table into query string applying percent-encoding.

Usage:
  > to url query

Flags:
  -h, --help - Display the help message for this command

Signatures:
  <record> | to url query -> <string>
  <table> | to url query -> <string>

Examples:
  Outputs a query string representing the contents of this record
  > { mode:normal userid:31415 } | to url query

  Outputs a query string representing the contents of this 1-row table
  > [[foo bar]; ["1" "2"]] | to url query

  Outputs a query string representing the contents of this record
  > {a:"AT&T", b: "AT T"} | to url query
```

# Tests + Formatting

Added this test:
```
Example {
    description: "Outputs a query string representing the contents of this record",
    example: r#"{a:"AT&T", b: "AT T"} | to url query"#,
    result: Some(Value::test_string("a=AT%26T&b=AT+T")),
},
```
to ensure percent-encoding. 

# After Submitting

If PR is accepted I'll open another PR on documentation to notify
changes on
[this.](https://github.com/nushell/nushell.github.io/blob/main/book/commands/to_url.md)

crates/nu-command/src/network/url/build_query.rs

@@ -0,0 +1,124 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{
+    Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Type, Value,
+};
+
+#[derive(Clone)]
+pub struct SubCommand;
+
+impl Command for SubCommand {
+    fn name(&self) -> &str {
+        "url build-query"
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::build("url build-query")
+            .input_output_types(vec![
+                (Type::Record(vec![]), Type::String),
+                (Type::Table(vec![]), Type::String),
+            ])
+            .category(Category::Network)
+    }
+
+    fn usage(&self) -> &str {
+        "Converts record or table into query string applying percent-encoding."
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["convert", "record", "table"]
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Outputs a query string representing the contents of this record",
+                example: r#"{ mode:normal userid:31415 } | url build-query"#,
+                result: Some(Value::test_string("mode=normal&userid=31415")),
+            },
+            Example {
+                description: "Outputs a query string representing the contents of this 1-row table",
+                example: r#"[[foo bar]; ["1" "2"]] | url build-query"#,
+                result: Some(Value::test_string("foo=1&bar=2")),
+            },
+            Example {
+                description: "Outputs a query string representing the contents of this record",
+                example: r#"{a:"AT&T", b: "AT T"} | url build-query"#,
+                result: Some(Value::test_string("a=AT%26T&b=AT+T")),
+            },
+        ]
+    }
+
+    fn run(
+        &self,
+        _engine_state: &EngineState,
+        _stack: &mut Stack,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, ShellError> {
+        let head = call.head;
+        to_url(input, head)
+    }
+}
+
+fn to_url(input: PipelineData, head: Span) -> Result<PipelineData, ShellError> {
+    let output: Result<String, ShellError> = input
+        .into_iter()
+        .map(move |value| match value {
+            Value::Record {
+                ref cols,
+                ref vals,
+                span,
+            } => {
+                let mut row_vec = vec![];
+                for (k, v) in cols.iter().zip(vals.iter()) {
+                    match v.as_string() {
+                        Ok(s) => {
+                            row_vec.push((k.clone(), s.to_string()));
+                        }
+                        _ => {
+                            return Err(ShellError::UnsupportedInput(
+                                "Expected a record with string values".to_string(),
+                                "value originates from here".into(),
+                                head,
+                                span,
+                            ));
+                        }
+                    }
+                }
+
+                match serde_urlencoded::to_string(row_vec) {
+                    Ok(s) => Ok(s),
+                    _ => Err(ShellError::CantConvert(
+                        "URL".into(),
+                        value.get_type().to_string(),
+                        head,
+                        None,
+                    )),
+                }
+            }
+            // Propagate existing errors
+            Value::Error { error } => Err(error),
+            other => Err(ShellError::UnsupportedInput(
+                "Expected a table from pipeline".to_string(),
+                "value originates from here".into(),
+                head,
+                other.expect_span(),
+            )),
+        })
+        .collect();
+
+    Ok(Value::string(output?, head).into_pipeline_data())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(SubCommand {})
+    }
+}

crates/nu-command/src/network/url/mod.rs

@@ -1,3 +1,4 @@
+mod build_query;
 mod encode;
 mod parse;
 mod url_;
@@ -5,5 +6,6 @@ mod url_;
 use url::{self};
 
 pub use self::parse::SubCommand as UrlParse;
+pub use build_query::SubCommand as UrlBuildQuery;
 pub use encode::SubCommand as UrlEncode;
 pub use url_::Url;