BREAKING CHANGE: reqiures Picodata Tarantool with a string quoting
fix (e9360c989129a755b86486c7bcd6e2d21a078e22).

Now coordinator dispatches SQL patterns with separated parameters.
It would help us to cache patterns on the segments as prepared
statements one day and skip SQL parsing.

Also we have faced a Tarantool bug

https://github.com/tarantool/tarantool/issues/7283

and made a hot fix in the Picodata fork. As a result we have also
migrated sbroad CI to our fork.

We migrate from the `decimal` crate (used decQuad from decNumber
to store the numbers) to Tarantool internal types provided by the
Rust module. The reason was to make IR numeric values easy
serializable to the query parameters (a part of the executor
refactoring).

The problem with Tarantool internal types is that the internal
decNumber representation is provided by Tarantool ABI. So we always
need Tarantool itself to use the types. It is ok for integration
tests, but for unit tests with `cargo test` it is a problem. As a
solution we have implemented some mocking infrastructure to build
a static library based on the Tarantool decNumber, MsgPuck and some
wrappers over them both to make unit tests work.

We have fixed some bugs about NULL and made equality propagation
use the infrastructure common with the other transformations.

Also, extended and refactored the tests.

Planner may split some query into range of sub queries, where subquery
execution depends on results previous subquery. Then planner analyzes
query and if it finds similar situation he appends `motion` node to plan.
If executor finds `monion` node in execution plan, he executes
motion sub-query and saves result to virtual table, which linker will be used.

We need this refactoring to move all node plan methodes to the new
Nodes structure. Otherwise we have to put a mutable lock for the
whole plan structure rather then on the nodes list. It makes
porblems with API refactoring otherwise.

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()'.

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

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.