Functional API: Execution environment agnostic function

cc @karllessard

This is somewhat of a sub-task of #181. The biggest pain I've ran into when using ConcreteFunction is that it only has tensor call methods, when it's mostly going to be used with Operand. This is a fairly simple issue on the surface. But, there's no way to execute ConcreteFunction in graph mode, i.e. if they are nested. The function used to generate the graph-mode outputs (which are wrapped in Signature) isn't saved. Now, it's easy enough to do this Java-side, in a sub class so that ConcreteFunction still supports loading. However, there's other issues such as supporting inputs with different shapes and dtypes that made me realize that what I'm trying to do here is closer to Python's Function and we may want to handle it with a new abstraction. There's also TF_Function and TF_GraphCopyFunction and TFE_ContextAddFunction which seems like it would allow attaching a ConcreteFunction to a graph without having to re-execute the builder in a new graph.

So I'd propose two things:

• Implement Graph-mode and Eager-mode use of ConcreteFunctions using the native TF_Function APIs (the fact that the eager one doesn't mention gradients makes me a little worried, but I would think we can handle that manually later if necessary).
• Add a Function class that acts like tf.function, in that it creates ConcreteFunctions as necessary for the argument shapes and dtypes. Additionally, since this will save the graph-creator lambda, we can have a debug flag that re-runs the lambda.

We also need to do something with variable handling, although that will probably need to wait on #179. Python seems to use an implicit variable-creation context to create them at the call-site and only allows it on the first call. I'd be fine with throwing errors and forcing the user to extract them, I think. I need to look into the details a bit more before I propose anything for this though. Variable scopes might be worth doing anyways for freezing, although hopefully explicit as part of Ops/Scope.

We'll need to pay attention to Graph states, like random seeds, too.

Empieza con ConcreteFunction y las APIs nativas TF_Function, TF_GraphCopyFunction y TFE_ContextAddFunction mencionadas en la issue; compara cómo se representan la ejecución eager y la ejecución en modo grafo. Lee el contexto relacionado de #181 y #179 antes de definir el alcance. La tarea debería cubrir la abstracción Function acordada, la especialización de shape y dtype, el manejo de variables y el comportamiento del estado del grafo.