https://github.com/ruby/json/commit/4f1adb10d3

https://github.com/ruby/json/commit/1576ea7d47

Commit https://github.com/ruby/json/commit/44df509dc2de fixed it for StandardError, but other exceptions and
jumps are also possible. Use rb_ensure() to release FBuffer instead of
rb_rescue().

A reproducer:

    o = Object.new
    def o.to_json(a) = throw :a
    a = ["make heap allocation"*100, o]

    10.times do
      100_000.times do
        catch(:a) { JSON(a) }
      end

      puts `ps -o rss= -p #{$$}`
    end

https://github.com/ruby/json/commit/9b7b648ecd

Because both strings and symbols keys are serialized the same,
it always has been possible to generate documents with duplicated
keys:

```ruby
>> puts JSON.generate({ foo: 1, "foo" => 2 })
{"foo":1,"foo":2}
```

This is pretty much always a mistake and can cause various
issues because it's not guaranteed how various JSON parsers
will handle this.

Until now I didn't think it was possible to catch such case without
tanking performance, hence why I only made the parser more strict.

But I finally found a way to check for duplicated keys cheaply enough.

Helps with pretty printting performance:

```
== Encoding activitypub.json (52595 bytes)
ruby 3.4.2 (2025-02-15 revision https://github.com/ruby/json/commit/d2930f8e7a) +YJIT +PRISM [arm64-darwin24]
Warming up --------------------------------------
               after     1.746k i/100ms
Calculating -------------------------------------
               after     17.481k (± 1.0%) i/s   (57.20 μs/i) -     89.046k in   5.094341s

Comparison:
              before:    16038.4 i/s
               after:    17481.1 i/s - 1.09x  faster

== Encoding citm_catalog.json (500298 bytes)
ruby 3.4.2 (2025-02-15 revision https://github.com/ruby/json/commit/d2930f8e7a) +YJIT +PRISM [arm64-darwin24]
Warming up --------------------------------------
               after    60.000 i/100ms
Calculating -------------------------------------
               after    608.157 (± 2.3%) i/s    (1.64 ms/i) -      3.060k in   5.034238s

Comparison:
              before:      525.3 i/s
               after:      608.2 i/s - 1.16x  faster

== Encoding twitter.json (466906 bytes)
ruby 3.4.2 (2025-02-15 revision https://github.com/ruby/json/commit/d2930f8e7a) +YJIT +PRISM [arm64-darwin24]
Warming up --------------------------------------
               after   160.000 i/100ms
Calculating -------------------------------------
               after      1.606k (± 0.5%) i/s  (622.70 μs/i) -      8.160k in   5.081406s

Comparison:
              before:     1410.3 i/s
               after:     1605.9 i/s - 1.14x  faster
```

https://github.com/ruby/json/commit/f0dda861c5

https://github.com/ruby/json/commit/12656777dc

This would have caught https://github.com/ruby/json/pull/808
on CI.

https://github.com/ruby/json/commit/8109421fb4

Some relatively minor change to make the library more in line
with the gem. Some renaming, etc.

This commit provides an alternative implementation for a
long → decimal conversion.

The main difference is that it uses an algorithm pulled from
https://github.com/jeaiii/itoa.
The source there is C++, it was converted by hand to C for
inclusion with this gem.
jeaiii's algorithm is covered by the MIT License, see source code.

On addition this version now also generates the string directly into
the fbuffer, foregoing the need to run a separate memory copy.

As a result, I see a speedup of 32% on Apple Silicon M1 for an
integer set of benchmarks.