Tweak constants to reduce test execution time.

The idea behind the test is simple - create several invalid range files,
i.e. those left from previous dumps and incomplete splits, then restart
the server and check that the content of the space was not corrupted.

To make it possible, we need to (1) prevent the garbage collector from
removing unused range files and (2) make the split procedure fail after
successfully writing the first range. We use error injection to achieve
that.

The test runs as follows:

 1. Disable garbage collection with the aid of error injection.

 2. Add a number of tuples to the test space that would make it split.
    Rewrite them several times with different values so that different
    generations of ranges on disk would have different contents.

 3. Inject error to the split procedure.

 4. Rewrite the tuples another couple of rounds. This should trigger
    split which is going to fail leaving invalid range files with newer
    ids on the disk.

 5. Restart the server and check that the test space content was not
    corrupted.

Currently, we store all range ids in an .index file after each range
tree modification. On recovery, we open the latest .index file, get the
list of all ranges, and load them. This .index file introduces extra
complexity to the compaction task: as we can get a consistent list of
all range ids only in the tx thread, we must either write .index file
from the tx thread (which we do now), or introduce a special task for
it, which would be scheduled on compaction completion. The former way
degrades performance of the tx thread, while the latter complicates the
code.

Actually, we can do range recovery w/o having to maintain .index files:
as newer ranges always have greater ids, we can just recover ranges
starting from the greatest id and disregarding ranges that are already
spanned by the index tree. For instance, suppose range A was split in
ranges B and C. Then we recover ranges B and C first (they do not
intersect, so everything's fine), then we get to A and see that it is
already spanned (by B and C), so we just throw it away. If on split, B
(or C) was not created for some reason, then A will not be fully spanned
by the index, and we replace B (or C) with A, still getting a consistent
index view.

This patch implements the recovery process as per above and removes the
.index file. Note, to avoid loading stale index data after drop-create,
we have to name range files not only by id, but also by index lsn (just
like the .index files). As before, old range file removal is postponed
until checkpoint.

Rename range->min_key to range->begin, as it actually denotes not the
minimal key across all entries in the range, but the lower bound of the
range, and introduce range->end for the upper bound of the range.
For adjacent ranges left->end == right->begin. If a range is leftmost,
then range->begin == NULL. If a range is rightmost, then range->end ==
NULL. Store range->{begin,end} in range file on checkpoint and load them
on recovery.

This is required by the following patch to check that ranges do not
intersect.

All we need to initialize range->path is range->id and index->path. Both
are known at the time of range allocation and never change. So let's do
range->path initialization right in vy_range_new() instead of postponing
it until range recovery/write.

It is uninitialized in case of error injection.

Closes #1755

Closes #1725

vy_write_iterator_next() now is used for getting the next
tuple.
vy_write_iterator->curr_tuple was removed.
vy_write_iterator->keeping_tuple is used for keeping
the tuple that is need between two invocations of next() but
must be deleted after.
Fixed the memory management in vy_write_iterator_next.
Optimized purging in write_iterator.

We have env->indexes list. No need to store all indexes in an array in
addition to that. Note, I move rlist_add adding a new index to the
env->indexes list from vy_index_new() to vy_index_open() so that it only
becomes visible to the scheduler after having been successfully loaded.
This change does not make any difference apart from that.

All manipulations on index->refs, which ref_lock is supposed to protect,
are done from the tx thread, so the lock is not needed.

Move the miniature truncate test to gh.test.lua and remove disabled
test file.

Rename connection option 'legacy_call' to 'call_16'.
If you live long enough you know that even shiniest and brightiest
call's time may come.

Fix gh-799 net.box: use a single watcher
Fix gh-800 net.box: remove reconnect fiber
Fix gh-1138 net.box: an active connection is never garbage collected
Fix gh-1750 net.box: hangs after reconnect

  * Net.box() connection refuses to work with 'Lua console';
  * console method in net.box dropped (TBD: docs;)
  * internals changed, code depending on internals WILL break;
  * different state chart, see comments in source code (TBD: docs;)
  * new option: legacy_call to request call 1.6 semantics;
  * extension: option wait_connected treated as timeout if T == number;
  * wait_connected() return true/false as docs say;
  * wait_state() moved to public API (TBD: docs.)

Replace internal methods with public ones when possible.
Remove redundant calls.
Remove console tests - console support in net.box is being phased out.

Rename tests, reduce sleep interval, cleanup after the test a bit
more thoroughly, disable the test in release mode.

Error was with modifying primary key. In following case:
   upsert lsn=10, modify primary key
   upsert lsn=9,
   replace lsn=8
vy_apply_upsert returned replace,lsn=9, but answer must be
   upsert lsn=9 merge with replace lsn=8