Move Value to helpers, separate span call (#10121)

# Description

As part of the refactor to split spans off of Value, this moves to using
helper functions to create values, and using `.span()` instead of
matching span out of Value directly.

Hoping to get a few more helping hands to finish this, as there are a
lot of commands to update :)

# User-Facing Changes
<!-- List of all changes that impact the user experience here. This
helps us keep track of breaking changes. -->

# 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` to
check that you're using the standard code style
- `cargo test --workspace` to check that all tests pass (on Windows make
sure to [enable developer
mode](https://learn.microsoft.com/en-us/windows/apps/get-started/developer-mode-features-and-debugging))
- `cargo run -- -c "use std testing; testing run-tests --path
crates/nu-std"` to run the tests for the standard library

> **Note**
> from `nushell` you can also use the `toolkit` as follows
> ```bash
> use toolkit.nu # or use an `env_change` hook to activate it
automatically
> toolkit check pr
> ```
-->

# 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.
-->

---------

Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com>
Co-authored-by: WindSoilder <windsoilder@outlook.com>

crates/nu-protocol/src/eval_const.rs

@@ -244,22 +244,13 @@ pub fn eval_constant(
         Expr::Bool(b) => Ok(Value::bool(*b, expr.span)),
         Expr::Int(i) => Ok(Value::int(*i, expr.span)),
         Expr::Float(f) => Ok(Value::float(*f, expr.span)),
-        Expr::Binary(b) => Ok(Value::Binary {
-            val: b.clone(),
-            span: expr.span,
-        }),
-        Expr::Filepath(path) => Ok(Value::String {
-            val: path.clone(),
-            span: expr.span,
-        }),
+        Expr::Binary(b) => Ok(Value::binary(b.clone(), expr.span)),
+        Expr::Filepath(path) => Ok(Value::string(path.clone(), expr.span)),
         Expr::Var(var_id) => match working_set.get_variable(*var_id).const_val.as_ref() {
             Some(val) => Ok(val.clone()),
             None => Err(ShellError::NotAConstant(expr.span)),
         },
-        Expr::CellPath(cell_path) => Ok(Value::CellPath {
-            val: cell_path.clone(),
-            span: expr.span,
-        }),
+        Expr::CellPath(cell_path) => Ok(Value::cell_path(cell_path.clone(), expr.span)),
         Expr::FullCellPath(cell_path) => {
             let value = eval_constant(working_set, &cell_path.head)?;
 
@@ -275,19 +266,13 @@ pub fn eval_constant(
                 )),
             }
         }
-        Expr::DateTime(dt) => Ok(Value::Date {
-            val: *dt,
-            span: expr.span,
-        }),
+        Expr::DateTime(dt) => Ok(Value::date(*dt, expr.span)),
         Expr::List(x) => {
             let mut output = vec![];
             for expr in x {
                 output.push(eval_constant(working_set, expr)?);
             }
-            Ok(Value::List {
-                vals: output,
-                span: expr.span,
-            })
+            Ok(Value::list(output, expr.span))
         }
         Expr::Record(fields) => {
             let mut record = Record::new();
@@ -330,17 +315,11 @@ pub fn eval_constant(
                     expr.span,
                 ));
             }
-            Ok(Value::List {
-                vals: output_rows,
-                span: expr.span,
-            })
+            Ok(Value::list(output_rows, expr.span))
         }
         Expr::Keyword(_, _, expr) => eval_constant(working_set, expr),
-        Expr::String(s) => Ok(Value::String {
-            val: s.clone(),
-            span: expr.span,
-        }),
-        Expr::Nothing => Ok(Value::Nothing { span: expr.span }),
+        Expr::String(s) => Ok(Value::string(s.clone(), expr.span)),
+        Expr::Nothing => Ok(Value::nothing(expr.span)),
         Expr::ValueWithUnit(expr, unit) => {
             if let Ok(Value::Int { val, .. }) = eval_constant(working_set, expr) {
                 unit.item.to_value(val, unit.span)