json_view: faster float tokens of 16 to 19 digits (canada dump, traverse)

Reading:
- layout_decimal() reads tokens of 16 to 19 digits 16 bytes at a time
  (NEON / SSE2) and layout_float() sends them to Eisel-Lemire directly,
  without the fast-path check that mixed data mispredicts.

Dump (AArch64 only):
- Fixed-notation tokens of 16 or 17 digits are converted in batches ahead
  of the walk, one loop per step: digits, Eisel-Lemire, and an exact 8.56
  fixed-point choice of the shortest digits (shortest_token_digits(), in
  place of Zmij for these tokens). The output is the token with its last
  eight digits replaced. On x86-64 (Haswell, GCC 13 / Clang 18) the batch
  was not faster, so it is not used there.
- Output is byte-identical to the previous writer: 10^9 generated tokens
  on M1 (all exponents, subnormals, 15-18 digits, exact binary fractions,
  near-short decimals) and 2.5 * 10^8 on x86-64, plus canada, twitter and
  citm_catalog in compact, indented, and ensure_ascii form.

compare.py --download, M1 Max, clang 21, 30 rounds, two runs and aligned
builds; json_view, and the factor of yyjson 0.13.0 over it:
- canada dump      3636 -> 2597 us (0.47x -> 0.66x)
- canada traverse  2300 -> 2059 us (0.85x -> 0.96x)
- canada patch     4650 -> 3550 us (0.80x -> 1.05x)
- canada update    4882 -> 3813 us (0.78x -> 1.00x)
Linux x86-64 (umbrella, GCC 13): canada traverse 0.89x -> 0.95x, patch
0.98x -> 1.02x, update 0.96x -> 1.01x, dump 0.53x -> 0.57x.

Open: the dump and traverse targets (>= 1.0x) are missed. The dump is
bounded by the shortest-digits step (~8 ns per float, one multiply chain
per float). Three rows are more than 1 % slower than before in both the
plain and the aligned build, without a known cause (the parser's machine
code is identical, and these documents do not use the new float path):
- edit status patch          +2.7 % (aligned +1.9 %)
- edit citm_catalog update   +1.7 % (aligned +1.5 %)
- view jeopardy select       +1.4 % (aligned +1.0 %)

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

tests/src/unit-json_view_dump.cpp

@@ -150,6 +150,68 @@ TEST_CASE("json_view dump")
             CHECK(many_doc.root().dump() == json::parse(many_tokens).dump());
         }
 
+        // tokens of 16 and 17 digits without an exponent (like GeoJSON
+        // coordinates), which dump() converts in batches: random digits, and
+        // digits near a shorter decimal (...99999997, ...00000003), whose
+        // rounding carries; in pairs and among other values, so that the
+        // batches are interrupted; the last token near the end of the coordinates
+        {
+            std::mt19937_64 tokens(5627); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
+            const auto draw = [&tokens](std::size_t n)
+            {
+                const std::uint64_t r = tokens() % n;
+                return static_cast<std::size_t>(r);
+            };
+            std::string coordinates = "[";
+            for (int i = 0; i < 20000; ++i)
+            {
+                const std::size_t length = 16 + draw(2);
+                std::string digits(1, static_cast<char>('1' + draw(9)));
+                const std::size_t kept = draw(3) == 0 ? length : 2 + draw(length - 3);
+                for (std::size_t k = 1; k < kept; ++k)
+                {
+                    digits += static_cast<char>('0' + draw(10));
+                }
+                digits += std::string(length - kept, draw(2) == 0 ? '9' : '0');
+                digits.back() = static_cast<char>('0' + draw(10));
+                const std::size_t point = 1 + draw(9);
+                const std::string token = (draw(2) == 0 ? "-" : "") + digits.substr(0, point) + "." + digits.substr(point);
+                coordinates += (i != 0 ? "," : "") + (draw(8) == 0 ? "{\"x\":" + token + ",\"s\":\"a\"}" : "[" + token + "," + token + "]");
+            }
+            coordinates += ",-65.613616999999977]";
+            const json_document parsed = json_document::parse(coordinates);
+            const ordered_json j = ordered_json::parse(coordinates);
+            CHECK(parsed.root().dump() == j.dump());
+            CHECK(parsed.root().dump(1) == j.dump(1));
+            CHECK(parsed.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
+            CHECK(parsed.root().back().get<double>() == j.back().get<double>());
+            CHECK(parsed.root().back().dump() == "-65.61361699999998");
+            std::size_t i = 0;
+            for (const json_view v : parsed.root())
+            {
+                const ordered_json& e = j[i++];
+                CHECK(v.dump() == e.dump());
+                if (v.is_array())
+                {
+                    CHECK(v[0].get<double>() == e[0].get<double>());
+                }
+            }
+
+            // an editable document: edits move some arrays, so that the walk
+            // leaves the order of the parsed nodes
+            ordered_json_editable_document editable = ordered_json_editable_document::parse(coordinates);
+            ordered_json expected = j;
+            for (std::size_t k = 0; k < 20000; k += 97)
+            {
+                if (expected[k].is_array())
+                {
+                    editable.push_back(editable.root()[k], ordered_json(1.5));
+                    expected[k].push_back(1.5);
+                }
+            }
+            CHECK(editable.root().dump() == expected.dump());
+        }
+
         // random doubles, written as parse() and dump() would
         std::mt19937_64 rng(1170); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
         std::string many = "[";