Name the Value conversion functions more clearly (#11851)

# Description
This PR renames the conversion functions on `Value` to be more consistent.
It follows the Rust [API guidelines](https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv) for ad-hoc conversions.
The conversion functions on `Value` now come in a few forms:
- `coerce_{type}` takes a `&Value` and attempts to convert the value to
`type` (e.g., `i64` are converted to `f64`). This is the old behavior of
some of the `as_{type}` functions -- these functions have simply been
renamed to better reflect what they do.
- The new `as_{type}` functions take a `&Value` and returns an `Ok`
result only if the value is of `type` (no conversion is attempted). The
returned value will be borrowed if `type` is non-`Copy`, otherwise an
owned value is returned.
- `into_{type}` exists for non-`Copy` types, but otherwise does not
attempt conversion just like `as_type`. It takes an owned `Value` and
always returns an owned result.
- `coerce_into_{type}` has the same relationship with `coerce_{type}` as
`into_{type}` does with `as_{type}`.
- `to_{kind}_string`: conversion to different string formats (debug,
abbreviated, etc.). Only two of the old string conversion functions were
removed, the rest have been renamed only.
- `to_{type}`: other conversion functions. Currently, only `to_path`
exists. (And `to_string` through `Display`.)

This table summaries the above:
| Form | Cost | Input Ownership | Output Ownership | Converts `Value`
case/`type` |
| ---------------------------- | ----- | --------------- |
---------------- | -------- |
| `as_{type}` | Cheap | Borrowed | Borrowed/Owned | No |
| `into_{type}` | Cheap | Owned | Owned | No |
| `coerce_{type}` | Cheap | Borrowed | Borrowed/Owned | Yes |
| `coerce_into_{type}` | Cheap | Owned | Owned | Yes |
| `to_{kind}_string` | Expensive | Borrowed | Owned | Yes |
| `to_{type}` | Expensive | Borrowed | Owned | Yes |

# User-Facing Changes
Breaking API change for `Value` in `nu-protocol` which is exposed as
part of the plugin API.

crates/nu-protocol/src/config/helper.rs

@@ -15,7 +15,7 @@ pub(super) fn process_string_enum<T, E>(
     E: Display,
 {
     let span = value.span();
-    if let Ok(v) = value.as_string() {
+    if let Ok(v) = value.coerce_string() {
         match v.parse() {
             Ok(format) => {
                 *config_point = format;

crates/nu-protocol/src/config/mod.rs

@@ -320,7 +320,7 @@ impl Value {
                                                             process_int_config(value, &mut errors, &mut config.max_external_completion_results);
                                                         }
                                                         "completer" => {
-                                                            if let Ok(v) = value.as_block() {
+                                                            if let Ok(v) = value.coerce_block() {
                                                                 config.external_completer = Some(v)
                                                             } else {
                                                                 match value {
@@ -539,7 +539,7 @@ impl Value {
                                     process_bool_config(value, &mut errors, &mut config.filesize_metric);
                                 }
                                 "format" => {
-                                    if let Ok(v) = value.as_string() {
+                                    if let Ok(v) = value.coerce_string() {
                                         config.filesize_format = v.to_lowercase();
                                     } else {
                                         report_invalid_value("should be a string", span, &mut errors);
@@ -707,14 +707,14 @@ impl Value {
                                 let span = value.span();
                                 match key2 {
                                 "normal" => {
-                                    if let Ok(v) = value.as_string() {
+                                    if let Ok(v) = value.coerce_string() {
                                         config.datetime_normal_format = Some(v);
                                     } else {
                                         report_invalid_value("should be a string", span, &mut errors);
                                     }
                                 }
                                 "table" => {
-                                    if let Ok(v) = value.as_string() {
+                                    if let Ok(v) = value.coerce_string() {
                                         config.datetime_table_format = Some(v);
                                     } else {
                                         report_invalid_value("should be a string", span, &mut errors);

crates/nu-protocol/src/config/table.rs

@@ -251,7 +251,7 @@ pub(super) fn try_parse_trim_strategy(
         }
         TrimStrategy::Truncate { suffix } => {
             if let Some(value) = map.get("truncating_suffix") {
-                if let Ok(v) = value.as_string() {
+                if let Ok(v) = value.coerce_string() {
                     *suffix = Some(v);
                 } else {
                     errors.push(ShellError::GenericError {
@@ -272,7 +272,7 @@ pub(super) fn try_parse_trim_strategy(
 }
 
 fn try_parse_trim_methodology(value: &Value) -> Option<TrimStrategy> {
-    if let Ok(value) = value.as_string() {
+    if let Ok(value) = value.coerce_string() {
         match value.to_lowercase().as_str() {
         "wrapping" => {
             return Some(TrimStrategy::Wrap {