Use nucleo instead of skim for completions (#14846)

# Description

This PR replaces `SkimMatcherV2` from the
[fuzzy-matcher](https://docs.rs/fuzzy-matcher/latest/fuzzy_matcher/)
crate with the
[nucleo-matcher](https://docs.rs/nucleo-matcher/latest/nucleo_matcher/)
crate for doing fuzzy matching. This touches both our completion code in
`nu-cli` and symbol filtering in `nu-lsp`.

Nucleo should give us better performance than Skim. In the event that we
decide to use the Nucleo frontend ([crate
docs](https://docs.rs/nucleo/latest/nucleo/)) too, it also works on
Windows, unlike [Skim](https://github.com/skim-rs/skim), which appears
to only support Linux and MacOS.

Unfortunately, we still have an indirect dependency on `fuzzy-matcher`,
because the [`dialoguer`](https://github.com/console-rs/dialoguer) crate
uses it.

# User-Facing Changes

No breaking changes. Suggestions will be sorted differently, because
Nucleo uses a different algorithm from Skim for matching/scoring.
Hopefully, the new sorting will generally make more sense.

# Tests + Formatting

In `nu-cli`, modified an existing test, but didn't test performance. I
haven't tested `nu-lsp` manually, but existing tests pass.

I did manually do `ls /nix/store/<TAB>`, `ls /nix/store/d<TAB>`, etc.,
but didn't notice Nucleo being faster (my `/nix/store` folder has 34136
items at the time of writing).

crates/nu-cli/src/completions/completion_options.rs

@@ -1,7 +1,10 @@
-use fuzzy_matcher::{skim::SkimMatcherV2, FuzzyMatcher};
 use nu_parser::trim_quotes_str;
 use nu_protocol::{CompletionAlgorithm, CompletionSort};
 use nu_utils::IgnoreCaseExt;
+use nucleo_matcher::{
+    pattern::{AtomKind, CaseMatching, Normalization, Pattern},
+    Config, Matcher, Utf32Str,
+};
 use std::{borrow::Cow, fmt::Display};
 
 use super::SemanticSuggestion;
@@ -34,9 +37,10 @@ enum State<T> {
         items: Vec<(String, T)>,
     },
     Fuzzy {
-        matcher: Box<SkimMatcherV2>,
+        matcher: Matcher,
+        pat: Pattern,
         /// Holds (haystack, item, score)
-        items: Vec<(String, T, i64)>,
+        items: Vec<(String, T, u32)>,
     },
 }
 
@@ -46,30 +50,37 @@ impl<T> NuMatcher<T> {
     ///
     /// * `needle` - The text to search for
     pub fn new(needle: impl AsRef<str>, options: CompletionOptions) -> NuMatcher<T> {
-        let orig_needle = trim_quotes_str(needle.as_ref());
-        let lowercase_needle = if options.case_sensitive {
-            orig_needle.to_owned()
-        } else {
-            orig_needle.to_folded_case()
-        };
+        let needle = trim_quotes_str(needle.as_ref());
         match options.match_algorithm {
-            MatchAlgorithm::Prefix => NuMatcher {
-                options,
-                needle: lowercase_needle,
-                state: State::Prefix { items: Vec::new() },
-            },
-            MatchAlgorithm::Fuzzy => {
-                let mut matcher = SkimMatcherV2::default();
-                if options.case_sensitive {
-                    matcher = matcher.respect_case();
+            MatchAlgorithm::Prefix => {
+                let lowercase_needle = if options.case_sensitive {
+                    needle.to_owned()
                 } else {
-                    matcher = matcher.ignore_case();
+                    needle.to_folded_case()
                 };
                 NuMatcher {
                     options,
-                    needle: orig_needle.to_owned(),
+                    needle: lowercase_needle,
+                    state: State::Prefix { items: Vec::new() },
+                }
+            }
+            MatchAlgorithm::Fuzzy => {
+                let pat = Pattern::new(
+                    needle,
+                    if options.case_sensitive {
+                        CaseMatching::Respect
+                    } else {
+                        CaseMatching::Ignore
+                    },
+                    Normalization::Smart,
+                    AtomKind::Fuzzy,
+                );
+                NuMatcher {
+                    options,
+                    needle: needle.to_owned(),
                     state: State::Fuzzy {
-                        matcher: Box::new(matcher),
+                        matcher: Matcher::new(Config::DEFAULT),
+                        pat,
                         items: Vec::new(),
                     },
                 }
@@ -102,8 +113,15 @@ impl<T> NuMatcher<T> {
                 }
                 matches
             }
-            State::Fuzzy { items, matcher } => {
-                let Some(score) = matcher.fuzzy_match(haystack, &self.needle) else {
+            State::Fuzzy {
+                matcher,
+                pat,
+                items,
+            } => {
+                let mut haystack_buf = Vec::new();
+                let haystack_utf32 = Utf32Str::new(trim_quotes_str(haystack), &mut haystack_buf);
+                let mut indices = Vec::new();
+                let Some(score) = pat.indices(haystack_utf32, matcher, &mut indices) else {
                     return false;
                 };
                 if let Some(item) = item {