Enable `ocamlopt` inlining
Add `bench_llio`

This module implements some basic benchmarks for the `Llio` module,
using `core_bench`.

The benchmark assumes there's a baseline implementation in the
`Llio_orig` module (make a copy of `llio.ml` and `llio.mli` to
`llio_orig.ml` and `llio_orig.mli` before making your changes).

You can build to executable using

```
$ ocamlbuild -use-ocamlfind -package core_bench -I tools bench_llio.native
```

Then run `./bench_llio.native -help` for some documentation.
Optimize several `Llio` functions

This commit makes several changes to functions in the `Llio` module in
order to use more efficient compiler primops to speed up some things, or
reduce allocation rates by reducing the construction of intermediate
values.

Using `bench_llio` to compare the new code to the `Llio` code before
these changes (in `Llio_orig`) yields the following result:

```
$ nice -20 taskset 01 ./bench_llio.native time cycles alloc gc
Estimated testing time 2.33333m (14 benchmarks x 10s). Change using -quota SECS.
┌────────────────────────┬────────────┬────────────┬────────────┬────────────┬──────────┬─────────────┬───────────┬──────────┬────────────┐
│ Name                   │   Time/Run │  Cycls/Run │    mWd/Run │   mjWd/Run │ Prom/Run │     mGC/Run │  mjGC/Run │ Comp/Run │ Percentage │
├────────────────────────┼────────────┼────────────┼────────────┼────────────┼──────────┼─────────────┼───────────┼──────────┼────────────┤
│ Llio_orig.int32_to     │   380.08us │   910.10kc │   337.94kw │  5_135.60w │   13.60w │ 1_289.12e-3 │  67.80e-3 │          │     19.83% │
│ Llio.int32_to          │   234.67us │   561.91kc │    20.49kw │  5_122.87w │    0.87w │    78.18e-3 │  39.08e-3 │ 13.02e-3 │     12.24% │
│ Llio_orig.int64_to     │   780.96us │ 1_869.99kc │   583.70kw │ 10_268.03w │   26.03w │ 2_226.57e-3 │ 130.35e-3 │ 43.47e-3 │     40.74% │
│ Llio.int64_to          │   224.66us │   537.95kc │    30.73kw │ 10_243.30w │    1.30w │   117.22e-3 │  39.08e-3 │          │     11.72% │
│ Llio_orig.output_int32 │ 1_390.64us │ 3_329.88kc │ 1_111.14kw │    136.44w │  136.44w │ 4_238.61e-3 │   0.97e-3 │          │     72.54% │
│ Llio.output_int32      │   906.28us │ 2_170.08kc │   701.53kw │    107.74w │  107.74w │ 2_676.07e-3 │   0.81e-3 │  0.06e-3 │     47.27% │
│ Llio_orig.output_int64 │ 1_917.15us │ 4_590.61kc │ 1_505.38kw │    176.94w │  176.94w │ 5_742.52e-3 │   0.96e-3 │          │    100.00% │
│ Llio.output_int64      │ 1_106.83us │ 2_650.29kc │   839.77kw │    124.14w │  124.14w │ 3_203.48e-3 │   0.68e-3 │          │     57.73% │
│ Llio_orig.input_int32  │ 1_195.78us │ 2_863.29kc │   860.18kw │     77.61w │   77.61w │ 3_281.25e-3 │   0.38e-3 │          │     62.37% │
│ Llio.input_int32       │ 1_187.08us │ 2_842.46kc │   829.46kw │     77.29w │   77.29w │ 3_164.11e-3 │   0.39e-3 │          │     61.92% │
│ Llio_orig.input_int    │ 1_319.21us │ 3_158.83kc │   901.14kw │     81.24w │   81.24w │ 3_437.49e-3 │   0.27e-3 │          │     68.81% │
│ Llio.input_int         │ 1_319.84us │ 3_160.34kc │   870.41kw │     27.85w │   27.85w │ 3_320.44e-3 │   0.18e-3 │          │     68.84% │
│ Llio_orig.input_int64  │ 1_377.37us │ 3_298.10kc │   993.30kw │    101.89w │  101.89w │ 3_789.21e-3 │   0.48e-3 │          │     71.84% │
│ Llio.input_int64       │ 1_370.06us │ 3_280.59kc │   962.58kw │    100.93w │  100.93w │ 3_671.91e-3 │   0.28e-3 │          │     71.46% │
└────────────────────────┴────────────┴────────────┴────────────┴────────────┴──────────┴─────────────┴───────────┴──────────┴────────────┘
```

See
https://github.com/janestreet/core_bench/wiki/Getting-Started-with-Core_bench
for a description of the columns.

Whilst this shows some nice speedups in non-`Lwt` code and some modest
enhancements in `Lwt`-based code, also notice the reduced allocation
rates, e.g. in `input_int`, which can have quite some impact in code
which goes beyond what a micro-benchmark does.
Merge pull request #444 from Incubaid/optimize_llio

Optimize `Llio`