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 library and tests already use ranges:: algorithms extensively
  (e.g. ranges::sort everywhere); this makes the remaining full-range
  calls consistent with that style.
• Drops an all(...) macro expansion (relevant when expanding KACTL
  macros on main).

Scope / what is intentionally NOT changed

• std::partial_sum and std::accumulate — no ranges::
  numeric-reduction equivalents in C++23 (ranges::fold_left would change
  the idiom), 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).

[cameroncuster]

Superseded by #244 (branch renamed use-ranges-iota -> use-ranges-algorithms as scope expanded to ranges::unique/partition/remove_if/next_permutation across library + tests).