update human-date-parser to 3.0 (#15426)

# Description

There's been much debate about whether to keep human-date-parser in
`into datetime`. We saw recently that a new version of the crate was
released that addressed some of our concerns. This PR is to make it
easier to test those fixes.

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

# 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/conversions/into/datetime.rs

@@ -294,7 +294,7 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
             match parse_date_from_string(&input_val, span) {
                 Ok(date) => return Value::date(date, span),
                 Err(_) => {
-                    if let Ok(date) = from_human_time(&input_val) {
+                    if let Ok(date) = from_human_time(&input_val, Local::now().naive_local()) {
                         match date {
                             ParseResult::Date(date) => {
                                 let time = Local::now().time();
@@ -307,7 +307,29 @@ fn action(input: &Value, args: &Arguments, head: Span) -> Value {
                                 return Value::date(dt_fixed, span);
                             }
                             ParseResult::DateTime(date) => {
-                                return Value::date(date.fixed_offset(), span)
+                                let local_offset = *Local::now().offset();
+                                let dt_fixed = match local_offset.from_local_datetime(&date) {
+                                    chrono::LocalResult::Single(dt) => dt,
+                                    chrono::LocalResult::Ambiguous(_, _) => {
+                                        return Value::error(
+                                            ShellError::DatetimeParseError {
+                                                msg: "Ambiguous datetime".to_string(),
+                                                span,
+                                            },
+                                            span,
+                                        );
+                                    }
+                                    chrono::LocalResult::None => {
+                                        return Value::error(
+                                            ShellError::DatetimeParseError {
+                                                msg: "Invalid datetime".to_string(),
+                                                span,
+                                            },
+                                            span,
+                                        );
+                                    }
+                                };
+                                return Value::date(dt_fixed, span);
                             }
                             ParseResult::Time(time) => {
                                 let date = Local::now().date_naive();