prefer ranges algorithms over iterator-pair std calls (library + tests)

[cameroncuster]

What

Prefer the ranges:: algorithms over their iterator-pair std::
counterparts for full-range calls, across both the library and the
test suite. The rule: use ranges:: even when all() would work, unless
iterators specifically make more sense.

Conversions applied:

• iota(all(x), v) → ranges::iota(x, v)
• unique(all(x)) → begin(ranges::unique(x)) (erase / == end idioms)
• partition(all(x), pred) → begin(ranges::partition(x, pred))
• remove_if(all(x), pred) → begin(ranges::remove_if(x, pred)) (erase)
• next_permutation(all(x)) → ranges::next_permutation(x).found

ranges::unique / ranges::partition / ranges::remove_if return a
subrange, so begin(...) yields the iterator the erase / offset logic
needs; ranges::next_permutation returns a struct whose .found drives
the do/while.

Why

The consistency signal is the goal, not raw source length. #221
("standardize on c++20: ranges/views where shorter") used a
shorter-in-this-repo heuristic and, on that basis, reverted the
subrange-returning algos (unique / remove_if / partition) back to
iterator form. This PR intentionally revisits that for one reason:

• The all(x) macro expands on main. When KACTL macros are
  expanded for the published notebook, all(x) becomes
  begin(x), end(x), so the iterator form unique(begin(x), end(x)) is
  actually longer than begin(ranges::unique(x)). The
  "shorter" heuristic that motivated the standardize on c++20: ranges/views and <bit> used consistently #221 revert inverts once the
  macro is gone — so the ranges:: form is the one that stays clean in
  the shipped code.
• Consistency with existing style. The library and tests already use
  ranges:: algorithms extensively (e.g. ranges::sort everywhere);
  these conversions close the remaining full-range gaps rather than
  leaving a mix of idioms.

Scope / what is intentionally NOT changed

• std::partial_sum and std::accumulate — no ranges::
  numeric-reduction equivalents in C++23 (ranges::fold_left would be
  longer and change the idiom: accumulate(all(v), 0) →
  fold_left(v, 0, plus{})), so these stay as-is.
• Partial-range calls (iterator sub-ranges such as
  lower_bound(begin(sa) + lo, ...), find_if(rank + begin(mat), ...),
  partition(el, er, ...), remove_if(idx + begin(upd_st), ...)) — read
  more clearly with explicit iterators.
• Member functions named find / count — not std:: algorithms.
• Scalar std::min / std::max.

Files

library/ (12 sites, 12 files): line_tree, mst,
offline_incremental_scc, complement_graph_ccs, calc_sieve,
calc_linear_sieve, lcs_dp, longest_palindrome_query, suffix_array (2),
suffix_array_short (iota); virtual_tree (unique); edge_cd (partition).

tests/ (10 files): bit_ordered_set, kth_smallest_pst, mode_query,
sa_sort_pairs, seg_tree_find (unique); mono_st_asserts,
offline_incremental_scc, sa_sort_pairs (iota); permutation_tree_small,
rmq_small_n (iota + next_permutation); single_matching_bs (remove_if).

Testing

Syntax-checked all affected library-checker/aizu tests locally with
clang++ -std=c++2b -fsyntax-only — all pass.

Behaviorally ran (exit 0, all asserts pass):

• edge_cd_small_trees — exhaustive over all trees on 2–7 nodes
  (ranges::partition).
• lca_all_methods_aizu — includes compress_tree_asserts, comparing
  compress_tree against KACTL's reference over random subsets plus the
  empty-subset edge case (ranges::unique).
• permutation_tree_small and rmq_small_n — exhaustive over all
  permutations of size 1–8 (ranges::next_permutation(...).found,
  ranges::iota).