Picodata was bumped to rust 1.71.0, so sbroad as its submodule can
finally update the rust version as well.

Current commit redesigns distributed INSERT command. Previously we
dispatched insert SQL command to the storages. If INSERT could be
done locally (without building a virtual table on the router) we
used SQL "bucket_id(<string>)" function to recalculate buckets
on the starage via SQL.

This approach had the main disadvantage - it worked only with a
"bucket_id" SQL function that had a single argument as a parameter.
An attempt to support multiple parameters of different types (tuple
columns as we plan to implement for Picodata engine in future) faced
serious technical problems.
Also, the old implementation had performance issues:
- we created temporary spaces on the storage even for a single VALUE
  insertion
- we always dispatched VALUES to the storage to build a virtual table
- the resulting SQL was too verbose (as we produced a subquery under
  INSERT node)

It was desided to get rid of the old approach and migrate to non-SQL
insertion. It means that a new type of motion was introduled - local
segment. It allows us to build a virtual table on the storage in
Rust memory, then using space API transform and insert collected tuples
directly into the target space within a single transaction. Also we
can materailize VALUES (if they contain only constants) on the router
and get rid of the redundant network transmission over the network.

Implement the picodata engine for sbroad to integrate distributed
SQL into the picodata binary. In fact, picodata engine simple
exports public rust functions from api.rs. On the picodata side
they (and some lua functions) are imported and included into the
bunary on the build phase.

Current commit is POC and have some problems:
- DDL is still not implemented in the picodata (_pico_space is mocked);
- we include tarantool module symbols twice (first time in sbroad,
  second time in picodata binary);

But anyway, it works and all these problems should be solved in the
next commits.

The traits to plug new engines became more clear. It would help us
while implementing the picodata engine.

The configuration cache is a part of the executor's runtime.
Previously, quech query was holding a immutable borrow of the
runtime, while cache invalidation tried to get a mutable borrow
(apply_config). As a result, the cache invalidation always failed
to mutably borrow the runtime.
Current commit fixes the issue by wrapping the configuration in
a reference cell. As a result, apply_config now immutably borrows
the runtime and don't fail on this step.

We stop using VALUES to store temporary tuple on the storages and
switch to the tarantool spaces instead. This is done to avoid the
problems with the auto generated column names in VALUES, parser
stack and parameters limitations.

Tarantool forbids to use multiple space engines in a single transaction.
So for vinyl tables we have to use vinyl spaces as a tepmorary storage.
For memtx tables we can use temporary memtx spaces.

One more important change is that we can't insert values of
different numeric types in a number column (as we don't cast them
as the local SQL does).

Reduce the amount of the heap allocations (use recursion instead of
the heap stack).

Now we support a flashback traversal for the subtree iterator. As
a result we can traverse the original selections in a way they looked
before any transformations were applied. This solves the problem
of too verbose DNFs that can easily reach tarantool's parser stack
limit.

Now sbroad has distributed SQL functions in the core crate. At the
momnet there is only a single implementation of the `bucket_id()`
function.