109.53.00

- Added `Float.to_string_round_trippable`, which produces a string
  that loses no precision but (usually) uses as few digits as
  possible.

  This can eliminate noise at the end (e.g. `3.14` not
  `3.1400000000000001243`).

  Benchmarks:

  New sexp:

  ```ocaml
  ┌────────────────────────┬──────────┬─────────┬────────────┐
  │ Name                   │ Time/Run │ mWd/Run │ Percentage │
  ├────────────────────────┼──────────┼─────────┼────────────┤
  │ new Float.sexp_of 3.14 │ 463.28ns │   6.00w │     48.88% │
  │ new Float.sexp_of e    │ 947.71ns │  12.00w │    100.00% │
  └────────────────────────┴──────────┴─────────┴────────────┘
  ```

  Old sexp:

  ```ocaml
  ┌────────────────────────┬──────────┬─────────┬────────────┐
  │ Name                   │ Time/Run │ mWd/Run │ Percentage │
  ├────────────────────────┼──────────┼─────────┼────────────┤
  │ old Float.sexp_of 3.14 │ 841.99ns │ 178.00w │     98.03% │
  │ old Float.sexp_of e    │ 858.94ns │ 178.00w │    100.00% │
  └────────────────────────┴──────────┴─────────┴────────────┘
  ```

  Much of the speedup in the 3.14 case comes from the fact that
  `format_float "%.15g"` is much faster than `sprintf "%.15g"`.  And
  of course the above does not capture any of the benefits of dealing
  with shorter strings down the road.

  Here are some detailed benchmarks of the various bits and pieces of
  what's going on here:

  ```ocaml
  ┌─────────────────────────────────────┬────────────┬─────────┬────────────┐
  │ Name                                │   Time/Run │ mWd/Run │ Percentage │
  ├─────────────────────────────────────┼────────────┼─────────┼────────────┤
  │ format_float '%.15g' 3.14           │   335.96ns │   2.00w │     32.71% │
  │ format_float '%.17g' 3.14           │   394.18ns │   4.00w │     38.38% │
  │ format_float '%.20g' 3.14           │   459.79ns │   4.00w │     44.77% │
  │ format_float '%.40g' 3.14           │   638.06ns │   7.00w │     62.13% │
  │ sprintf '%.15g' 3.14                │   723.71ns │ 165.00w │     70.47% │
  │ sprintf '%.17g' 3.14                │   803.44ns │ 173.00w │     78.23% │
  │ sprintf '%.20g' 3.14                │   920.78ns │ 176.00w │     89.66% │
  │ sprintf '%.40g' 3.14                │   990.09ns │ 187.00w │     96.41% │
  │ format_float '%.15g' e              │   357.59ns │   4.00w │     34.82% │
  │ format_float '%.17g' e              │   372.16ns │   4.00w │     36.24% │
  │ format_float '%.20g' e              │   434.59ns │   4.00w │     42.32% │
  │ format_float '%.40g' e              │   592.78ns │   7.00w │     57.72% │
  │ sprintf '%.15g' e                   │   742.12ns │ 173.00w │     72.26% │
  │ sprintf '%.17g' e                   │   747.92ns │ 173.00w │     72.83% │
  │ sprintf '%.20g' e                   │   836.30ns │ 176.00w │     81.43% │
  │ sprintf '%.40g' e                   │ 1_026.96ns │ 187.00w │    100.00% │
  │ valid_float_lexem 12345678901234567 │    76.29ns │   9.00w │      7.43% │
  │ valid_float_lexem 3.14              │     9.28ns │   5.00w │      0.90% │
  │ float_of_string 3.14                │   130.19ns │   2.00w │     12.68% │
  │ float_of_string 1234567890123456.7  │   184.33ns │   2.00w │     17.95% │
  │ to_string 3.14                      │   316.47ns │   7.00w │     30.82% │
  │ to_string_round_trippable 3.14      │   466.02ns │   9.00w │     45.38% │
  │ to_string e                         │   315.41ns │   7.00w │     30.71% │
  │ to_string_round_trippable e         │   949.12ns │  15.00w │     92.42% │
  └─────────────────────────────────────┴────────────┴─────────┴────────────┘
  ```

- Replaced `Float.min_positive_value` with `min_positive_normal_value`
  and `min_positive_subnormal_value`.
- Added some functions to `Float.O`: `abs`, `of_float`, and
  `Robustly_comparable.S`.
- Small improvements to the `Heap` module.

  Implemented `Heap.iter` directly rather than in terms of `fold`.

  In `heap.ml`, fixed the idiom for using `Container.Make`.
- Added an `Int.O` and other `Int*.O` modules, with arithmetic
  operators, infix comparators, and a few useful arithmetic values.
- Added `Int.( ~- )`, for unary negation.
- Added `Pool.unsafe_free`.
- Added `Percent` module.