Make string related commands parse-time evaluatable (#13032)

<!--
if this PR closes one or more issues, you can automatically link the PR
with
them by using one of the [*linking
keywords*](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword),
e.g.
- this PR should close #xxxx
- fixes #xxxx

you can also mention related issues, PRs or discussions!
-->

Related meta-issue: #10239.

# Description
<!--
Thank you for improving Nushell. Please, check our [contributing
guide](../CONTRIBUTING.md) and talk to the core team before making major
changes.

Description of your pull request goes here. **Provide examples and/or
screenshots** if your changes affect the user experience.
-->

This PR will modify some `str`-related commands so that they can be
evaluated at parse time.

See the following list for those implemented by this pr.

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

Available now:
- `str` subcommands
  - `trim`
  - `contains`
  - `distance`
  - `ends-with`
  - `expand`
  - `index-of`
  - `join`
  - `replace`
  - `reverse`
  - `starts-with`
  - `stats`
  - `substring`
  - `capitalize`
  - `downcase`
  - `upcase`
- `split` subcommands
  - `chars`
  - `column`
  - `list`
  - `row`
  - `words`
- `format` subcommands
  - `date`
  - `duration`
  - `filesize`
- string related commands
  - `parse`
  - `detect columns`
  - `encode` & `decode`

# 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 toolkit.nu; toolkit test stdlib"` 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
> ```
-->

Unresolved questions:
- [ ] Is there any routine of testing const expressions? I haven't found
any yet.
- [ ] Is const expressions required to behave just like there non-const
version, like what rust promises?

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

Unresolved questions:
- [ ] Do const commands need special marks in the docs?

crates/nu-command/src/strings/str_/trim/trim_.rs

@@ -71,6 +71,10 @@ impl Command for SubCommand {
         vec!["whitespace", "strip", "lstrip", "rstrip"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -79,44 +83,37 @@ impl Command for SubCommand {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let character = call.get_flag::<Spanned<String>>(engine_state, stack, "char")?;
-        let to_trim = match character.as_ref() {
-            Some(v) => {
-                if v.item.chars().count() > 1 {
-                    return Err(ShellError::GenericError {
-                        error: "Trim only works with single character".into(),
-                        msg: "needs single character".into(),
-                        span: Some(v.span),
-                        help: None,
-                        inner: vec![],
-                    });
-                }
-                v.item.chars().next()
-            }
-            None => None,
-        };
         let cell_paths: Vec<CellPath> = call.rest(engine_state, stack, 0)?;
-        let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
-        let mode = match cell_paths {
-            None => ActionMode::Global,
-            Some(_) => ActionMode::Local,
-        };
-
         let left = call.has_flag(engine_state, stack, "left")?;
         let right = call.has_flag(engine_state, stack, "right")?;
-        let trim_side = match (left, right) {
-            (true, true) => TrimSide::Both,
-            (true, false) => TrimSide::Left,
-            (false, true) => TrimSide::Right,
-            (false, false) => TrimSide::Both,
-        };
-
-        let args = Arguments {
-            to_trim,
-            trim_side,
+        run(
+            character,
             cell_paths,
-            mode,
-        };
-        operate(action, args, input, call.head, engine_state.ctrlc.clone())
+            (left, right),
+            call,
+            input,
+            engine_state,
+        )
+    }
+
+    fn run_const(
+        &self,
+        working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let character = call.get_flag_const::<Spanned<String>>(working_set, "char")?;
+        let cell_paths: Vec<CellPath> = call.rest_const(working_set, 0)?;
+        let left = call.has_flag_const(working_set, "left")?;
+        let right = call.has_flag_const(working_set, "right")?;
+        run(
+            character,
+            cell_paths,
+            (left, right),
+            call,
+            input,
+            working_set.permanent(),
+        )
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -150,6 +147,52 @@ impl Command for SubCommand {
     }
 }
 
+fn run(
+    character: Option<Spanned<String>>,
+    cell_paths: Vec<CellPath>,
+    (left, right): (bool, bool),
+    call: &Call,
+    input: PipelineData,
+    engine_state: &EngineState,
+) -> Result<PipelineData, ShellError> {
+    let to_trim = match character.as_ref() {
+        Some(v) => {
+            if v.item.chars().count() > 1 {
+                return Err(ShellError::GenericError {
+                    error: "Trim only works with single character".into(),
+                    msg: "needs single character".into(),
+                    span: Some(v.span),
+                    help: None,
+                    inner: vec![],
+                });
+            }
+            v.item.chars().next()
+        }
+        None => None,
+    };
+
+    let cell_paths = (!cell_paths.is_empty()).then_some(cell_paths);
+    let mode = match cell_paths {
+        None => ActionMode::Global,
+        Some(_) => ActionMode::Local,
+    };
+
+    let trim_side = match (left, right) {
+        (true, true) => TrimSide::Both,
+        (true, false) => TrimSide::Left,
+        (false, true) => TrimSide::Right,
+        (false, false) => TrimSide::Both,
+    };
+
+    let args = Arguments {
+        to_trim,
+        trim_side,
+        cell_paths,
+        mode,
+    };
+    operate(action, args, input, call.head, engine_state.ctrlc.clone())
+}
+
 #[derive(Debug, Copy, Clone)]
 pub enum ActionMode {
     Local,