Switch to a caller-rooted arguments calling convention for Rust exported functions

[tizoc]

Changes

• Switched exported functions to a caller-rooted arguments call convention. Now such functions receive &OCamlRooted<T> parameters.
• Added to_rust(cr) method to OCamlRooted<T> values.
• Removed ToRust trait and implemented to_rust() directly into OCaml<T>.
• Added keep_from_raw method to root values, an unsafe version of keep_raw that returns an OCamlRooted<T> instead of an OCamlRawRooted.

Continued in #17

[tizoc]

@zshipko I'm making some big changes to the calling convention here, but the result will be a far simpler model that will not require macros to call OCaml functions (which are required for handling all the lifetime-related dance). I don't think it should have much impact on how ocaml-derive handles exported functions.

tl;dr is that now every Rust function exposed to OCaml receives rooted (&OCamlRooted<T>) arguments, and every function imported from OCaml will have to be called with rooted arguments too. For the time being this sill probably incur a small overhead, but if the OCaml runtime/compiler adds support for this calling convention, that should go away.

Another change is that exceptions will not be converted into Errs anymore, but instead panic by default. I have to figure out an abstraction that lets the user handle these exceptions when required. The idea here is that the OCaml-side should present any failure situation by returning Result.t values instead of raising exceptions, and any exception that is raised from the OCaml-side will be considered as unexpected.