Also move this Plan implementation method to expressions.

Also "set_distribution()" function is a Plan method now.

BREAKING CHANGE: move from branch-based references in the tuple to
the array-based. Also add a logical ID to all relational nodes and
keep it in all its child tuples.

Now, our reference coordination system in a tuple looks like:
- parent relational node logical ID (we don't know actual position
  in the nodes list, so use "secondary index")
- target - i.e. a position of the reffered node in the relational
  node's children list
- posirtion in the reffered relational child node output tuple

Previously distribution was calculated in the node constructor. It
is a wrong design as the tree would be transformed multiple times
and there is no reason to recalculate distribution on each step.
We need distribution only on the last transformation when we insert
Motion nodes. So, this refactoring makes tuple distribution optional
and moves distribution logic to a separate function 'set_distribution()'.

feat: migrate getting vshard count of buckets from lua to rust and added tarantool logging to proxy functions

Was fixed interaction format between lua and sbroad rust lib. In current implementation sbroad encodes query result to yaml and send it to lua app. Lua app gives yaml and decodes it to lua table. After apply this changes lua app will receive lua table and yaml transformations will not be needed.

We need it to serialize IR to SQL correctly - otherwise we'll lose
information about subquery name. Not good.

Migration to tarantool module master branch for more conformable working
with Lua calls.

Move this logic to a separate function and add one more test.

Previously,  unit tests and code lived in the same '*.rs' file.
We have written too much tests and these files became bloated
(up to 1000 lines) - it is difficult to navigate them. So, lets
make a refactoring.

Now we can build it with cargo doc.

We expect that every relational node contains a reference to the
row expression node, that contains only aliases (expressions with
names). We need this convention to simplify SQL -> IR transformation.

Previously we had an alias only for reference, that was strange and
incorrect. Now we can add an alias name to any expression in the
tuple.

At the moment IR (logical plan) is far from final release. Current
commit fixes some point on a way to the final API and full test
coverage.

It was done that decrease coupling working with lua in code and make
migration to rust module master branch more simple. Besides was fixed bug for working with query string variable in execute_sql function in unsafe block, because in this place was buffer overflow.

Add sql executor function binding.

Made cartridge application for integartion tests. Was created lua interface
for bucket id calculate function.

1. Implement columns (with types) and tables as a part of IR.
2. Use serde deserialization trait to build tables from YAML files.
   It would be also helpful when writing tests for arbitrary plan
   transformations.

To work with Calcite and Tarantool the planner needs to store values
in the plan leaf nodes. These values should be defined with exact types.
At the moment we need only several primitive types:
- boolean
- null
- number (decimal from decnumber library)
- string

As the planner analyzes SQL, it has to work with tree-valued logic
(3VL). At the moment we'll need only equivalence operation, so it
was implemented for the values in a 3VL manner.

Change algorithm for working with cluster schema (#18). Before change schema
was parsed from string on every query.Now schema store in global state
and update at first query after new cartridge schema applying.

Also rust-fmt was applied.