Reduced LOC by replacing several instances of Value::Int {}, Value::Float{}, Value::Bool {}, and Value::String {} with Value::int(), Value::float(), Value::boolean() and Value::string() (#7412)

# Description

While perusing Value.rs, I noticed the `Value::int()`, `Value::float()`,
`Value::boolean()` and `Value::string()` constructors, which seem
designed to make it easier to construct various Values, but which aren't
used often at all in the codebase. So, using a few find-replaces
regexes, I increased their usage. This reduces overall LOC because
structures like this:
```
Value::Int {
  val: a,
  span: head
}
```
are changed into
```
Value::int(a, head)
```
and are respected as such by the project's formatter.
There are little readability concerns because the second argument to all
of these is `span`, and it's almost always extremely obvious which is
the span at every callsite.

# User-Facing Changes

None.

# Tests + Formatting

Don't forget to add tests that cover your changes.

Make sure you've run and fixed any issues with these commands:

- `cargo fmt --all -- --check` to check standard code formatting (`cargo
fmt --all` applies these changes)
- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A
clippy::needless_collect` to check that you're using the standard code
style
- `cargo test --workspace` to check that all tests pass

# After Submitting

If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.

crates/nu-command/src/filesystem/cd.rs

@@ -163,10 +163,7 @@ impl Command for Cd {
 
         let path_tointo = path.clone();
         let path_value = Value::String { val: path, span };
-        let cwd = Value::String {
-            val: cwd.to_string_lossy().to_string(),
-            span: call.head,
-        };
+        let cwd = Value::string(cwd.to_string_lossy(), call.head);
 
         let mut shells = get_shells(engine_state, stack, cwd);
         let current_shell = get_current_shell(engine_state, stack);
@@ -181,10 +178,7 @@ impl Command for Cd {
         );
         stack.add_env_var(
             "NUSHELL_CURRENT_SHELL".into(),
-            Value::Int {
-                val: current_shell as i64,
-                span: call.head,
-            },
+            Value::int(current_shell as i64, call.head),
         );
 
         if let Some(oldpwd) = stack.get_env_var(engine_state, "PWD") {

crates/nu-command/src/filesystem/watch.rs

@@ -170,13 +170,7 @@ impl Command for Watch {
 
                     if let Some(position) = block.signature.get_positional(0) {
                         if let Some(position_id) = &position.var_id {
-                            stack.add_var(
-                                *position_id,
-                                Value::String {
-                                    val: operation.to_string(),
-                                    span: call.span(),
-                                },
-                            );
+                            stack.add_var(*position_id, Value::string(operation, call.span()));
                         }
                     }
 
@@ -184,10 +178,7 @@ impl Command for Watch {
                         if let Some(position_id) = &position.var_id {
                             stack.add_var(
                                 *position_id,
-                                Value::String {
-                                    val: path.to_string_lossy().to_string(),
-                                    span: call.span(),
-                                },
+                                Value::string(path.to_string_lossy(), call.span()),
                             );
                         }
                     }
@@ -196,13 +187,10 @@ impl Command for Watch {
                         if let Some(position_id) = &position.var_id {
                             stack.add_var(
                                 *position_id,
-                                Value::String {
-                                    val: new_path
-                                        .unwrap_or_else(|| "".into())
-                                        .to_string_lossy()
-                                        .to_string(),
-                                    span: call.span(),
-                                },
+                                Value::string(
+                                    new_path.unwrap_or_else(|| "".into()).to_string_lossy(),
+                                    call.span(),
+                                ),
                             );
                         }
                     }