Stub generation for function bindings

Fixes #15.  

## What this adds

* A low-level interface for generating C stubs and OCaml code for binding those stubs from a function name and type.  The [interface] is exposed as a single module,  [Cstubs](https://github.com/yallop/ocaml-ctypes/blob/easy-stubs/src/cstubs/cstubs.mli),  which generates code from a  [Ctypes.fn](https://github.com/ocamllabs/ocaml-ctypes/blob/68e5687/src/ctypes/ctypes.mli#L250-L253)  value.  There are four functions:
  
  * [Cstubs.write_c](https://github.com/yallop/ocaml-ctypes/blob/easy-stubs/src/cstubs/cstubs.mli#L10-L13) writes a C stub to a [formatter](http://caml.inria.fr/pub/docs/manual-ocaml/libref/Format.html#TYPEformatter).
  
  * [Cstubs.write_ml](https://github.com/yallop/ocaml-ctypes/blob/easy-stubs/src/cstubs/cstubs.mli#L19-L24) writes an OCaml binding for a C stub to a formatter.

  * [Cstubs.write_signature](https://github.com/yallop/ocaml-ctypes/blob/easy-stubs/src/cstubs/cstubs.mli#L30-L34) writes an OCaml signature a binding to a formatter.
  
  * [Cstubs.register_paths](https://github.com/yallop/ocaml-ctypes/blob/easy-stubs/src/cstubs/cstubs.mli#L36-L39) records the path at which a [view](https://github.com/ocamllabs/ocaml-ctypes/blob/68e5687/src/ctypes/ctypes.mli#L330-L352) or [structured type](https://github.com/ocamllabs/ocaml-ctypes/blob/68e5687/src/ctypes/ctypes.mli#L271-L328) definition can be found, for use in generated code.

* The form of the generated code depends on the input type.  For simple cases, such as functions which accept and return primitives, the generated OCaml code is simply an [external](http://caml.inria.fr/pub/docs/manual-ocaml-4.00/manual033.html#toc142) declaration:

```c
value add_stub(value, value);
```
```ocaml
external add : int -> int -> int = "add_stub"
```

If the types involved are more complicated --- e.g., views or structured types --- then the generated OCaml will also include a wrapper function for translating between the low-level representation used by C and the high-level OCaml types:

```c
value strstr_stub(value, value);
```
```ocaml
external strstr : pointer -> pointer -> pointer = "add_stub"
val strstr : string @-> string @-> string
```

If there are lots of arguments you'll get an [extra function generated for use in bytecode mode](http://caml.inria.fr/pub/docs/manual-ocaml-4.00/manual033.html#htoc251):

```c
value polyadic_stub(value, value, value, value, value, value);
```
```ocaml
value polyadic_stub_byte6(value *, int);
external polyadic : int -> int -> int -> int -> int -> int -> int
   = "polyadic_stub_byte6" "polyadic_stub"
```

* A new findlib package [ctypes.stubs](https://github.com/yallop/ocaml-ctypes/blob/easy-stubs/META#L21-L30).

* Support for a number of things not available with the [foreign/libffi backend](https://github.com/ocamllabs/ocaml-ctypes/blob/68e568774/src/ctypes-foreign-unthreaded/foreign.mli):

  * passing arbitrary structs by value

      `foreign`/`libffi` doesn't currently support passing or returning structs with union members (for example).  The stub generation backend has no restrictions on the types of struct arguments or return types.

  * passing unions by value
  
      `foreign`/`libffi` doesn't currently support passing or returning unions by value.  The stub generation backend allows unions as arguments and return types.

  * calling function-like macros and builtins
  
      `foreign` resolves function names dynamically; it offers no way to access compile-time entities such as macros.  The stub generation backend uses the API exposed by the headers of a C library, and so doesn't differentiate between functions and function-like macros.
  
* Type checking for C calls.  Since the stub generation works by generating C code for compilation by a C compiler, mistakes in type declarations result in a compile-time diagnostic rather than a runtime error.

* You can mix and match the stub generation approaches.  For example, the `foreign` package provides [a way to pass OCaml functions as C function pointers](https://github.com/ocamllabs/ocaml-ctypes/blob/68e568774/src/ctypes-foreign-unthreaded/foreign.mli#L38-L52), which is not possible using pure stub generation.  A hybrid approach --- generating a C stub which receives a function pointer built by `foreign` --- combines the advantages of both packages.

* The [examples](https://github.com/yallop/ocaml-ctypes/tree/easy-stubs/examples) and the [tests](https://github.com/yallop/ocaml-ctypes/tree/easy-stubs/examples) have been converted to use both the foreign and the stub generation backends.

## What's not yet supported

* The `noalloc` and `float` attributes are not yet supported, although the [analysis](https://github.com/yallop/ocaml-ctypes/blob/easy-stubs/src/cstubs/cstubs_analysis.ml) is implemented.

* There is currently no stub-generation equivalent for the [check_errno](https://github.com/ocamllabs/ocaml-ctypes/blob/68e568774/src/ctypes-foreign-unthreaded/foreign.mli#L13) argument to `foreign`.

* "CV-qualifiers" such as `const` and `volatile` are not yet supported, so stubs generated for functions involving `const` may generate diagnostics.

* There's no support for `typedef` yet, so it's not possible to generate stubs for C functions involving "anonymous" types such as the following:

```c
typedef struct { int x, y; } point;
point midpoint(point, point);
```

* There's currently no analogue of [foreign_value](https://github.com/ocamllabs/ocaml-ctypes/blob/68e568774/src/ctypes-foreign-unthreaded/foreign.mli#L33-L36).