Improve case insensitivity consistency (#10884)

# Description

Add an extension trait `IgnoreCaseExt` to nu_utils which adds some case
insensitivity helpers, and use them throughout nu to improve the
handling of case insensitivity. Proper case folding is done via unicase,
which is already a dependency via mime_guess from nu-command.

In actuality a lot of code still does `to_lowercase`, because unicase
only provides immediate comparison and doesn't expose a `to_folded_case`
yet. And since we do a lot of `contains`/`starts_with`/`ends_with`, it's
not sufficient to just have `eq_ignore_case`. But if we get access in
the future, this makes us ready to use it with a change in one place.

Plus, it's clearer what the purpose is at the call site to call
`to_folded_case` instead of `to_lowercase` if it's exclusively for the
purpose of case insensitive comparison, even if it just does
`to_lowercase` still.

# User-Facing Changes

- Some commands that were supposed to be case insensitive remained only
insensitive to ASCII case (a-z), and now are case insensitive w.r.t.
non-ASCII characters as well.

# Tests + Formatting

- 🟢 `toolkit fmt`
- 🟢 `toolkit clippy`
- 🟢 `toolkit test`
- 🟢 `toolkit test stdlib`

---------

Co-authored-by: Stefan Holderbach <sholderbach@users.noreply.github.com>

crates/nu-command/src/platform/input/input_listen.rs

@@ -345,9 +345,9 @@ fn get_keycode_name(head: Span, code: &KeyCode) -> (Value, Value) {
     let (typ, code) = match code {
         KeyCode::F(n) => ("f", n.to_string()),
         KeyCode::Char(c) => ("char", c.to_string()),
-        KeyCode::Media(m) => ("media", format!("{m:?}").to_lowercase()),
-        KeyCode::Modifier(m) => ("modifier", format!("{m:?}").to_lowercase()),
-        _ => ("other", format!("{code:?}").to_lowercase()),
+        KeyCode::Media(m) => ("media", format!("{m:?}").to_ascii_lowercase()),
+        KeyCode::Modifier(m) => ("modifier", format!("{m:?}").to_ascii_lowercase()),
+        _ => ("other", format!("{code:?}").to_ascii_lowercase()),
     };
     (Value::string(typ, head), Value::string(code, head))
 }
@@ -365,7 +365,7 @@ fn parse_modifiers(head: Span, modifiers: &KeyModifiers) -> Value {
     let parsed_modifiers = ALL_MODIFIERS
         .iter()
         .filter(|m| modifiers.contains(**m))
-        .map(|m| format!("{m:?}").to_lowercase())
+        .map(|m| format!("{m:?}").to_ascii_lowercase())
         .map(|string| Value::string(string, head))
         .collect();