Now that the network layer is exception aware, slowly
transit with the rest of Tarantool subsistems to
exception-based error handling model.

Make sure fiber_create() throws an exception
if there is insufficient memory for fiber or its
stack. Make the rest of the code aware of the change.

Dont' malloc() struct coio.
It's tiny and safe (unless ev_io_start() is done) to pass
around by value.

Make all subsystems (administrative console,
replication, memcached, binary protocol) use exception-based
socket API (sio.m).

Remove all fiber members related to socket I/O.
Remove fiber->peer and fiber->cookie.
The idea of the cookie is to preserve in the WAL
the originator of the request. This information is, however,
lost when saving a snapshot. To my knowledge there is no use
of this functionality, apart from pretty-printing
the WAL.

Peer is like cookie, but is textual and is used
for logging. However, now, as long as network errors
occur outside fiber context, most of the usefulness
is lost. The only remaining case is when someone is
trying to execute a write request on a read-only port.

For all other cases, sio.m already supplies SocketError
with peer name, and this is where it's most useful.

Change a single void * pointer passed to fiber_create
to a variadic list passed to every fiber_call().

Introduce two levels of new API: sio.h (the basic
socket IO) and evio.h (libev integrated socket IO).

Start changing the code base to use the new API.
Begin with replication.m.

When we recover either from a remote source or
from local log file/snapshot, a module "apply row" function
is invoked. Up until now this function
was invoked with a single argument - the row to apply,
and there were no context which would be passed around.

This worked fine as long as fibers were "all inclusive" --
i.e. contained all possible context which a function may need.

Now, when networking API and IO handles are split from
struct fiber, they need to be passed around explicitly,
in particular, into row apply function.

Prepeare the code base for this.

Conflicts:
	test/box/lua.result

- Add support for [sS] format in box.pack (16-bit integers)
- Add support for [b] ans [s] format in box.unpack (8 and 16-bit integers)
- Fix docs

Check if the number is in the 32-bit range before converting
it to a 32-bit int, in box.pack('p'). If the number is large,
convert it to a 64-bit integer.

Make box.lua just one of the many files which can be
compiled into the server.

Fix lbox_tonumber64 to not truncate large Lua numbers (which
don't fit into 32 bit range).

Make box.fiber.id() work according to the docs.

https://blueprints.launchpad.net/tarantool/+spec/support-bitwise-ops-in-lua

Make bitop available in the interpreter.
Extend the docs. Document tonumber64.

Same reasons apply as for Port objects: objc dispatch
is too expensive.

Don't use ObjC method dispatch for port I/O.

It's not strictly necessary, and, as long as port I/O
is used extensibly in the transaction processor loop,
produces visible changes in benchmark results.

Instantiate fiber IO buffers by value.

Why this is needed: in preparation for removal of network
IO from fiber code, make sure we do less juggling
with tbufs in fiber_gc().

Remove unused code.

user can't make new snapshot until previous snapshot is saving

* xlog/snapshot file format iterator object added (tnt_log)
* tnt_snapshot stream created
* refactored tnt_xlog and tnt_stream streams to use the same tnt_log object
* storage iterator added (for fetching tuples from snapshot or other
tuple storage)
* console client refactored to support snapshot files (cat command)
(this also fix for https://bugs.launchpad.net/tarantool/+bug/1028475)
* snapshot test case added

daemon can watch box.info.snapshotting variable do stop its loop temporary

A fix and a test case for Bug#0152018
"panic_on_wal_error doens't work for duplicate key errors"

Add a check for panic_if_error after invocation
of row handler, in addition to the log io cursor
checks.

(https://bugs.launchpad.net/tarantool/+bug/1050951)

A fix and a test case for Bug#1051006
"Tree iterators return garbage if an index is modified between calls"

Mark in a deleted node in sptree.h that it's been  put into the
garbage heap. When iterting over a garbage collected node, skip it,
and go up the stack until we find the first valid node.

This breaks the "sorted" quality of tree iterators in case there
are modifications between invocations of an iterator:
it is possible that a node is deleted and recycled, and we don't see
it in the iterator. When we go up the stack, we can jump to a different
part of the range than the one the recycled node belongs to.
. With this fix, it is also possible, that the iteration goes more
than once over entire tree range. But it's a good enough quick fix for a
crashing expire loop, which uses the tree iterator over the primary key to
scan the entire range and deletes expired keys on the go (additionally,
deletions may occur between invocations of the expire loop).