sort:Align sort debug key annotations with GNU coreutils (uutils#9468)

* fix: ignore NUL bytes in sort debug output alignment calculations

Replaced direct length checks with filtered counts excluding b'\0' in debug underline
and indentation output to prevent misalignment from embedded NUL characters, which
are often stripped during inspection. Added comprehensive tests for various sort
modes and inputs, including NUL byte scenarios, to verify correct debug annotations.

* feat: add locale-aware tests for sort debug key annotations

Split the existing `test_debug_key_annotations` into two tests: one for basic functionality and another for locale-specific behavior to handle conditional execution based on environment variables. Extracted a new helper function `debug_key_annotation_output` to generate debug output, improving test modularity and reducing code duplication. This enhances test coverage for debug key annotations in different numeric locales.

* refactor(test): optimize string building in debug_key_annotation_output for efficiency

Rework the `number` helper function to use a mutable String buffer with `writeln!` macro
instead of collecting intermediary vectors with `map` and `collect`. This reduces allocations
and improves performance in test output generation, building the numbered output directly
without extra string concatenations.

* refactor(tests): improve formatting and readability in sort test helpers

- Reformatted command-line arguments in test_debug_key_annotations_locale to fit on fewer lines
- Wrapped run_sort calls in debug_key_annotation_output for better code structure
- Minor reordering of output.push_str blocks for consistency and clarity

* refactor(test): embed expected debug key annotation outputs as constants

Replace fixture file reads with inline constants in test functions for
debug key annotations and locale variants. This makes the tests more
self-contained by removing dependencies on external fixture files.

* feat(sort): extract count_non_null_bytes for debug alignment

Add a helper function `count_non_null_bytes` to count bytes in a slice while ignoring embedded NULs. This improves code reusability and is used in debug underline output to ensure proper alignment by filtering NUL characters that may be present in selection strings. Replaces inline counting logic in two locations within the `Line` implementation.

Author: mattsu2020

src/uu/sort/src/sort.rs

@@ -221,6 +221,11 @@ impl SortMode {
     }
 }
 
+/// Return the length of the byte slice while ignoring embedded NULs (used for debug underline alignment).
+fn count_non_null_bytes(bytes: &[u8]) -> usize {
+    bytes.iter().filter(|&&c| c != b'\0').count()
+}
+
 pub struct Output {
     file: Option<(OsString, File)>,
 }
@@ -670,14 +675,19 @@ impl<'a> Line<'a> {
                 _ => {}
             }
 
+            // Don't let embedded NUL bytes influence column alignment in the
+            // debug underline output, since they are often filtered out (e.g.
+            // via `tr -d '\0'`) before inspection.
             let select = &line[..selection.start];
-            write!(writer, "{}", " ".repeat(select.len()))?;
+            let indent = count_non_null_bytes(select);
+            write!(writer, "{}", " ".repeat(indent))?;
 
             if selection.is_empty() {
                 writeln!(writer, "{}", translate!("sort-error-no-match-for-key"))?;
             } else {
                 let select = &line[selection];
-                writeln!(writer, "{}", "_".repeat(select.len()))?;
+                let underline_len = count_non_null_bytes(select);
+                writeln!(writer, "{}", "_".repeat(underline_len))?;
             }
         }