This is part 2 of #3379.

Add the spaceship operator

Part 1 had to disable some comparisons in unit tests because of incorrect results due to standard library code using 3-way comparison which, in the absence of a user-defined operator, compares the result of implicit conversions.
In part 2 we implement the spaceship operator and fix some inconsistencies in the old comparison code:

• NaN values always compare false/unordered when compared to themselves, other NaNs, or other numbers.
• Discarded values will always compare false/unordered to themselves or any other value, unless the legacy comparison behavior is explicitly enabled by defining the macro JSON_LEGACY_COMPARISON=1.
  When the legacy behavior is selected, operations that were computed as an odd number of inverses of other operations always return true. Example:
  Given two values lhs and rhs and at least one of them being a discarded value.
  1. (lhs < rhs) == false
  2. (lhs >= rhs) == true, because it is computed as !(lhs < rhs) (odd)
  3. (lhs > rhs) == false, because it is computed as !(lhs <= rhs) which is computed as !(rhs < lhs) (even)

GCC ignores user-defined operator<=> for enumerated types when rewriting operators. Clang, MSVC, and ICC do not. (ICC manages to produce an incorrect result anyway o.O.)
I've filed a bug with GCC but do agree now that GCC is following the letter of the standard. If anyone knows where to best raise concerns over a language defect, let me know.
it's easy enough to work around by defining operator< and explicitly delegating to operator<=>. Currently only enabled for GCC but almost guaranteed to be required for (some versions of) ICC.

The unit tests were updated in several ways:

• Defined equal-length constants for bool and std::partial::ordering.
  The goal was to find visually distinguishable names for true and false. T/F, t/f, tr/fa were all ruled out because they look too similar (in my editor anyway). f_ and _t aren't perfect but the best I've come up with so far.
• Replaced constants, aligned all tables, and numbered rows and columns.
• Added value_t::discarded to the list of types and updated tables.
• Added NaN and json(value_t::discarded) to the list of values and updated tables.
• Added tables for the results of 3-way comparisons.
• Cross-check comparisons with their 3-way comparison result and perform range check between both tables on traversal.
• Added test-comparison_legacy based on unit-comparison.cpp but with JSON_LEGACY_COMPARISON=1.
• Added a regression test to verify a unit test from unit-class_parser.cpp, which breaks with the new comparison behavior, continues to work in legacy mode.

Fix iterators to meet (more) std::ranges requirements

Unlike the unconstrained algorithms, which only declared named requirements, constrained algorithms and views use concepts to enforce requirements.
Some iterators did not meet enough of those requirements.
In this PR we ensure that iter_impl satisfies the std::bidirectional_iterator concept and iteration_proxy_value satisfies the std::input_iterator concept.

The apply*() functions included in an earlier revision were moved into a separate PR: #3450

---

To Do:

• Check iterator concepts in unit test.
• Add note about "magic keywords" to unit tests.
• Should JSON_LEGACY_COMPARISON=1 be added to CI?
• Should JSON_LEGACY_COMPARISON be renamed to JSON_LEGACY_DISCARDED_COMPARISON (or something else entirely) now that it only applies to discarded values?
• Document macro JSON_LEGACY_COMPARISON.
• Document macro JSON_HAS_THREE_WAY_COMPARISON.
• Document macro JSON_HAS_RANGES.
• Update operator documentation.
• Complete issue references in commit messages.

---

Fixes #3130.
Fixes #3409.

Related discussion: #3408