tensorflow/rust

According to the Tensorflow C API documentation:

  Graphs may be shared between sessions. Graphs are thread-safe when
  used as directed below.

Which presumably means when you use the C API as intended --- the C
API uses a mutex to control graph access/modification.

Tensor instances cannot be passed between threads, because Cell
is used for interior mutability to (lazily) unpack tensors of
types where the C and Rust representation differ.

This change creates two different tensor representations:

- TensorDataCRepr for types with identical C/Rust representations.
- TensorDataNoCRepr for types with different C/Rust representations.

Since TensorDataCRepr does not need unpacking, it is free from interior
mutability.

One of these two representations is used in Tensor, based on the tensor's
type.

The Buffer type seems to conflate ownership of the TF_Buffer object and the
ownership of the data wrapped by the TF_Buffer object.

A TF_Buffer object created through from_ptr() is created as 'borrowed'. As
a result, the TF_Buffer object is not deallocated, leadning to a memory
leak.

This commit makes two small changes to (hopefully) remedy the leak:

- from_ptr() sets the TF_Buffer to be owned, so that the drop() will
  deallocate the TF_Buffer object. Since the TF_Buffer does not have
  a data_deallocator set, the data is not freed when Buffer is dropped.
- into_ptr() does not change the TF_Buffer ownership, but instead sets
  data_deallocator to NULL. As a consequence, the caller becomes responsible
  for freeing the data and the TF_Buffer is deallocated by drop().