* Switch to PackPack for packages
* Use `packagecloud` deployment for packages instead of travis.sh script
* Use `script` deployment for sources instead of travis.sh script
* Package all branches, but upload only 1.6/1.7
* Move all Travis CI script into the single Makefile

extra/rpm are mot used anymore.

Follow up 6cc47f6a

Make it clear which order of bits the bloom filter and the bit library
use.

Follow up #1919

If we fail to delete a run file, we should keep info about it in the log
and retry deletion on the next snapshot. To achieve that, this patch
introduces a new type of record, VY_LOG_FORGET_RUN, which is written to
the new log on rotation if the run was successfully deleted. On recovery
(and hence rotation) we delete a run info only if it is "forgotten".
Deleted but unforgotten runs remain in the log so that we can retry
deletion on next rotation.

Closes #2029

This will help implement backup and replication.

Instead, just mark them as deleted, so that we could remove old run
files on snapshot.

On coalesce, we log run insertion to the resulting range after deletion
from the source range. This results in recreation of the run object on
recovery. The next patch will rework recovery so that run objects will
not be actually deleted from the recovery context, but rather marked as
deleted, so that reinsertion of a deleted range will result in ID
collision. To address that, let's teach VY_LOG_INSERT_RUN records to
handle not only insertion of a new run, but also a move of an existing
run to another range, and use it to move runs of the source range to the
resulting range before deletion of the source range when coalescing.

Thanks to the vinyl metadata log, we know in advance which indexes are
going to be dropped on WAL recovery, so we can skip loading them.

* Move platform-specific defines to tt_pthread.h
* Set sched.coro.stack only with ENABLE_ASAN

Please note that pthread_getattr_np() + pthread_attr_destroy()
combination is totaly broken on Glibc 2.12 (RHELL 6.x).

Fixes #2085

Fixes #1588

 - Upsert squash fiber doesn't expect the active in-memory tree to have
   no statements for the optimized key, but it can happen if the tree is
   dumped before the fiber is scheduled, in which case the fiber
   crashes. Fix this.
 - Upsert squash fiber dereferences index->space. Hence if the index is
   dropped before the fiber is scheduled, it will crash. Fix this by
   using mem->format instead of space->format.
 - Add a test case covering the bugs to vinyl/errinj.

dumped_statements equals vy_run_info::keys, no need to pass it around.

* Fix handling of credentials in session_run_on_XXX_triggers()
* Add a test case for privileges in on_connect/on_disconnect() triggers
* Remove exceptions from session_run_on_XXX_triggers()

Discovered during #1938

Closes #725

Fixes #2089

fix gh-1919

Move appropriate functions from memtx_hash to tuple.h/c

Fix some functions in bit library

Rumprun is a toolchain to build unikernels based on NetBSD/Rump kernel.
Compiled images can be booted on KVM/XEN and even on "bare metal".

Unfortunally, Tarantool unikernels are still not fully functional due to
bugs in libeio and LuaJIT. However, now we have a simple way to check
cross-compilation for BSD/Rumpkernel and to bake unikernels from the code:

    OS=rumprun DIST=hw packpack
    qemu-system-x86_64 -enable-kvm -kernel build/tarantool-1.7.3.265.img

We must wait end of the dump before
attempt to create an index in
a not empty space.

The run_count stat counter is used by the vinyl/gc test to determine if
compaction has completed: as soon as run_count is dropped, it checks if
run files are deleted. Run file deletion is done by a coeio task (see
vy_run_unlink_files()) and hence may yield, in which case the test will
fail, because it expects old run files to be deleted upon compaction
completion. Fix this by deleting files before adjusting stats on
compaction completion.

Currently, it is only used in vy_recovery_insert_run(), but it will be
used somewhere else soon.

We can't delete the index's files as soon as it is dropped, because we
still need them for recovery. So let's delete them on snapshot. Thanks
to the metadata log, we know which files to delete.

Closes #1860

We can't remove run files right after index removal, because that would
break recovery from WAL. So we can only do cleanup on snapshot. By that
time, all associated structures have been freed, which makes it
impossible to find the index directory. Therefore we need to store the
information required to lookup the index directory in the metadata log.
This information will be used for garbage collection.

Needed for #1860

 - Make vy_recovery_load_index() take vy_index_recovery_info to
   eliminate needless lookup of each index on log rotation. Add wrapper
   vy_recovery_load_index_by_id() to be used in vy_log_recover_index().
 - Add helper vy_recovery_replay() that loads all active indexes. Use it
   on log rotation so as not to reveal vy_recovery internals to vy_log.

Sophia was an experimental storage engine in 1.6.x.
Please use 'vinyl' engine in Tarantool 1.7 instead.

Closes #2040

Vinyl scheduler/checkpoint infrastructure relies on the fact that
vy_scheduler->mem_min_lsn is the minimum over vy_mem->min_lsn. Commit
72f5fe20 ("vinyl: fix misusage of lsregion_gc() API") broke this
assumption, which results in snapshot hang under certain conditions
(shown in the test case). Fix this.

Closes #2081

 Implement tuple cache boundaries. Now if the value is the first or
the last in EQ query, it is placed into the cache with a special mark.
The next query finds the mark and understands that there is no
reason to search the value in mems/runs.

 Also add only-one-value optimization into merge iterator: it now
stops in the second next_key call if the search key is full
(and the index in unique)

Since commit ba08c2a9 ("vinyl: rotate mem on ddl"), in-memory trees
can be rotated not only by dump/compaction tasks, but also by tx commit,
in case a DDL happened after the mem was created. Dump/compaction tasks
are unprepared for this - they always drop all frozen in-memory trees.
As a result, in case of DDL in the middle of dump/compaction execution,
an in-memory tree can be complete lost along with all its statements. To
fix this, let's count the number of trees we are actually dumping and
only delete them upon task completion.