ls: Implement -f flag to disable sorting and enable -a (uutils#8824)

* ls: implement -f flag with correct constant, color logic, and localization

Fix the -f flag implementation to properly enable all files display,
disable sorting, and handle color output correctly.

Changes:
- Correct UNSORTED_ALL constant from 'unsorted-all' to 'f'
- Fix color logic to honor explicit --color flag regardless of -f position
- Add French localization for ls-help-unsorted-all
- Add comprehensive integration tests for -f flag behavior

The explicit --color flag now always takes precedence over -f implicit
color disabling, matching expected CLI behavior.

* tests(ls): improve -f flag test assertions

Address maintainer feedback from PR uutils#8824 review:

1. test_f_flag_disables_sorting: Compare -f output with -a (sorted) and -U (unsorted)
   to prove sorting is actually disabled, not just that files appear in output

2. test_f_overrides_big_a: Rename from test_f_overrides_a_and_big_a and fix assertions
   to check for .. presence (distinguishes -f from -A) instead of .hidden (shown in both)

3. test_f_overrides_sort_flags: Use size-based files and explicit output comparisons
   to verify last-flag-wins behavior with deterministic ordering

4. test_big_u_overrides_f_sort: Use size-based files and verify -U participates
   in last-flag-wins by checking actual output order

All tests now properly validate flag interactions instead of just checking file presence.

* refactor(ls): use match expression in extract_sort

Replace if/else chain with match expression for improved readability
and more idiomatic Rust code. Uses match guards for index comparisons.

Addresses maintainer feedback from PR uutils#8824 review.

No functional changes - behavior remains identical.

* fix(ls): use snake_case for test variable names

Follow Rust naming conventions by converting variable names in -f flag
tests from mixed case (out_Af, out_fS, etc.) to snake_case (out_a_f,
out_f_s, etc.). This eliminates clippy warnings about non_snake_case
identifiers.

* tests: fix flaky ls tests that depend on filesystem directory order

The tests test_f_flag_disables_sorting, test_big_u_overrides_f_sort, and
test_f_overrides_sort_flags made incorrect assumptions that unsorted
directory order would always differ from sorted order. However,
fs::read_dir() returns entries in filesystem-dependent order which may
accidentally match sorted order on some filesystems.

Changes:
- Removed assertions comparing unsorted vs sorted outputs
- Added deterministic checks (e.g., verifying --sort after -f works)
- Added explicit order verification for size-sorted outputs
- Tests now verify flag precedence without relying on directory order

Fixes CI failures on Windows and SELinux platforms.

Quality checks passed:
- cargo fmt --check: ✓
- cargo clippy --test tests: ✓
- all 3 modified tests pass: ✓

* test: fix misleading test name for -U flag behavior

Renamed test_big_u_overrides_f_sort to test_big_u_participates_in_sort_flag_wins
to accurately reflect that it tests -U with -S interactions, not -f.

Author: naoNao89

src/uu/ls/locales/en-US.ftl

@@ -82,6 +82,7 @@ ls-help-author = Show author in long format. On the supported platforms,
 ls-help-all-files = Do not ignore hidden files (files with names that start with '.').
 ls-help-almost-all = In a directory, do not ignore all file names that start with '.',
   only ignore '.' and '..'.
+ls-help-unsorted-all = List all files in directory order, unsorted. Equivalent to -aU. Disables --color unless explicitly specified.
 ls-help-directory = Only list the names of directories, rather than listing directory contents.
   This will not follow symbolic links unless one of `--dereference-command-line
   (-H)`, `--dereference (-L)`, or `--dereference-command-line-symlink-to-dir` is

src/uu/ls/locales/fr-FR.ftl

@@ -82,6 +82,7 @@ ls-help-author = Afficher l'auteur en format long. Sur les plateformes supporté
 ls-help-all-files = Ne pas ignorer les fichiers cachés (fichiers dont les noms commencent par '.').
 ls-help-almost-all = Dans un répertoire, ne pas ignorer tous les noms de fichiers qui commencent par '.',
   ignorer seulement '.' et '..'.
+ls-help-unsorted-all = Liste tous les fichiers dans l'ordre du répertoire, non triés. Équivalent à -aU. Désactive --color sauf si spécifié explicitement.
 ls-help-directory = Lister seulement les noms des répertoires, plutôt que le contenu des répertoires.
   Ceci ne suivra pas les liens symboliques à moins qu'une des options
   `--dereference-command-line (-H)`, `--dereference (-L)`, ou

src/uu/ls/src/ls.rs

@@ -99,6 +99,7 @@ pub mod options {
     pub mod files {
         pub static ALL: &str = "all";
         pub static ALMOST_ALL: &str = "almost-all";
+        pub static UNSORTED_ALL: &str = "f";
     }
 
     pub mod sort {
@@ -437,12 +438,27 @@ fn extract_format(options: &clap::ArgMatches) -> (Format, Option<&'static str>)
 ///
 /// A Files variant representing the type of files to display.
 fn extract_files(options: &clap::ArgMatches) -> Files {
-    if options.get_flag(options::files::ALL) {
-        Files::All
-    } else if options.get_flag(options::files::ALMOST_ALL) {
+    let get_last_index = |flag: &str| -> usize {
+        if options.value_source(flag) == Some(clap::parser::ValueSource::CommandLine) {
+            options.index_of(flag).unwrap_or(0)
+        } else {
+            0
+        }
+    };
+
+    let all_index = get_last_index(options::files::ALL);
+    let almost_all_index = get_last_index(options::files::ALMOST_ALL);
+    let unsorted_all_index = get_last_index(options::files::UNSORTED_ALL);
+
+    let max_index = all_index.max(almost_all_index).max(unsorted_all_index);
+
+    if max_index == 0 {
+        Files::Normal
+    } else if max_index == almost_all_index {
         Files::AlmostAll
     } else {
-        Files::Normal
+        // Either -a or -f wins, both show all files
+        Files::All
     }
 }
 
@@ -452,37 +468,69 @@ fn extract_files(options: &clap::ArgMatches) -> Files {
 ///
 /// A Sort variant representing the sorting method to use.
 fn extract_sort(options: &clap::ArgMatches) -> Sort {
-    if let Some(field) = options.get_one::<String>(options::SORT) {
-        match field.as_str() {
-            "none" => Sort::None,
-            "name" => Sort::Name,
-            "time" => Sort::Time,
-            "size" => Sort::Size,
-            "version" => Sort::Version,
-            "extension" => Sort::Extension,
-            "width" => Sort::Width,
-            // below should never happen as clap already restricts the values.
-            _ => unreachable!("Invalid field for --sort"),
-        }
-    } else if options.get_flag(options::sort::TIME) {
-        Sort::Time
-    } else if options.get_flag(options::sort::SIZE) {
-        Sort::Size
-    } else if options.get_flag(options::sort::NONE) {
-        Sort::None
-    } else if options.get_flag(options::sort::VERSION) {
-        Sort::Version
-    } else if options.get_flag(options::sort::EXTENSION) {
-        Sort::Extension
-    } else if !options.get_flag(options::format::LONG)
-        && (options.get_flag(options::time::ACCESS)
-            || options.get_flag(options::time::CHANGE)
-            || options.get_one::<String>(options::TIME).is_some())
-    {
-        // If -l is not specified, -u/-c/--time controls sorting.
-        Sort::Time
-    } else {
-        Sort::Name
+    let get_last_index = |flag: &str| -> usize {
+        if options.value_source(flag) == Some(clap::parser::ValueSource::CommandLine) {
+            options.index_of(flag).unwrap_or(0)
+        } else {
+            0
+        }
+    };
+
+    let sort_index = options
+        .get_one::<String>(options::SORT)
+        .and_then(|_| options.indices_of(options::SORT))
+        .map(|mut indices| indices.next_back().unwrap_or(0))
+        .unwrap_or(0);
+    let time_index = get_last_index(options::sort::TIME);
+    let size_index = get_last_index(options::sort::SIZE);
+    let none_index = get_last_index(options::sort::NONE);
+    let version_index = get_last_index(options::sort::VERSION);
+    let extension_index = get_last_index(options::sort::EXTENSION);
+    let unsorted_all_index = get_last_index(options::files::UNSORTED_ALL);
+
+    let max_sort_index = sort_index
+        .max(time_index)
+        .max(size_index)
+        .max(none_index)
+        .max(version_index)
+        .max(extension_index)
+        .max(unsorted_all_index);
+
+    match max_sort_index {
+        0 => {
+            // No sort flags specified, use default behavior
+            if !options.get_flag(options::format::LONG)
+                && (options.get_flag(options::time::ACCESS)
+                    || options.get_flag(options::time::CHANGE)
+                    || options.get_one::<String>(options::TIME).is_some())
+            {
+                Sort::Time
+            } else {
+                Sort::Name
+            }
+        }
+        idx if idx == unsorted_all_index || idx == none_index => Sort::None,
+        idx if idx == sort_index => {
+            if let Some(field) = options.get_one::<String>(options::SORT) {
+                match field.as_str() {
+                    "none" => Sort::None,
+                    "name" => Sort::Name,
+                    "time" => Sort::Time,
+                    "size" => Sort::Size,
+                    "version" => Sort::Version,
+                    "extension" => Sort::Extension,
+                    "width" => Sort::Width,
+                    _ => unreachable!("Invalid field for --sort"),
+                }
+            } else {
+                Sort::Name
+            }
+        }
+        idx if idx == time_index => Sort::Time,
+        idx if idx == size_index => Sort::Size,
+        idx if idx == version_index => Sort::Version,
+        idx if idx == extension_index => Sort::Extension,
+        _ => Sort::Name,
     }
 }
 
@@ -540,13 +588,40 @@ fn extract_color(options: &clap::ArgMatches) -> bool {
         return false;
     }
 
-    match options.get_one::<String>(options::COLOR) {
+    let get_last_index = |flag: &str| -> usize {
+        if options.value_source(flag) == Some(clap::parser::ValueSource::CommandLine) {
+            options.index_of(flag).unwrap_or(0)
+        } else {
+            0
+        }
+    };
+
+    let color_index = options
+        .get_one::<String>(options::COLOR)
+        .and_then(|_| options.indices_of(options::COLOR))
+        .map(|mut indices| indices.next_back().unwrap_or(0))
+        .unwrap_or(0);
+    let unsorted_all_index = get_last_index(options::files::UNSORTED_ALL);
+
+    let color_enabled = match options.get_one::<String>(options::COLOR) {
         None => options.contains_id(options::COLOR),
         Some(val) => match val.as_str() {
             "" | "always" | "yes" | "force" => true,
             "auto" | "tty" | "if-tty" => stdout().is_terminal(),
             /* "never" | "no" | "none" | */ _ => false,
         },
+    };
+
+    // If --color was explicitly specified, always honor it regardless of -f
+    // Otherwise, if -f is present without explicit color, disable color
+    if color_index > 0 {
+        // Color was explicitly specified
+        color_enabled
+    } else if unsorted_all_index > 0 {
+        // -f present without explicit color, disable implicit color
+        false
+    } else {
+        color_enabled
     }
 }
 
@@ -1575,6 +1650,12 @@ pub fn uu_app() -> Command {
             .help(translate!("ls-help-almost-all"))
             .action(ArgAction::SetTrue),
     )
+    .arg(
+        Arg::new(options::files::UNSORTED_ALL)
+            .short('f')
+            .help(translate!("ls-help-unsorted-all"))
+            .action(ArgAction::SetTrue),
+    )
     .arg(
         Arg::new(options::DIRECTORY)
             .short('d')