Fix styler
Clarify tricky pieces of the code (at least make them clearer to yours
truly).
Fix a bug with incorrect return value from fwrite() & O_DIRECT.

Remove fiob_open_flags, use "mode" consistently.

Fixes gh-153.

Before introducing a stronger row handler API,
eradicate tbuf from log_io/recovery, and pass around
a pointer to row and row length instead.

Rename tarantool_pthread.h to tt_pthread.h

This is a pre-requisite for addition of Perl stored procedures.

Reorganize iproto parser (pickle) around two pointers at the request
parsing position and request end.
This makes the code more generic and easily usable in lua and
with new buffered I/O.

This also reduces the current widespread use of tbuf throughout
entire code base (good for future maintainability of the code).

Remove dependency of admin.m from the configuration file.
Remove txn->txn_flags from recover_row().

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.

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.

Failure recovery: don't confirm rolled back LSNs.
Transactions are rolled back in the order, reverse to the initiation
order. Thus we first confirm the greatest LSN, then the one
preceding it, and so on. If we confirm LSNs of these
transactions, it can be done only out of order.

At better diagnostics to the failure of partial write. Rewrite
save_snapshot() to produce more diagnostics.

Truncate the log file in case of a partial write:
simple lseek() to the last good offset is not enough,
since, if we choose to close the file, we may still have
garbage at the end of the file.

When there was a partial write, rollback would
first confirm LSNs of requests which are only trying
to enter the queue, and only then LSNs of committed
or rolled back events.

Always put requests into the queue, even if we know
that they will be rolled back. This guarantees
a correct LSN order in confirm_lsn().

Split the rollback queue around the first not written
request, not around the first request in the batch.
In case of a partial write we may have written
a few requests at the head of the batch.

Sync the WAL at close time.
Fix a race condition between wal_schedule and ev_schedule
this revealed.

A cancelled fiber could get scheduled by wal_schedule.
Do not allow to asynchronously cancel a fiber which
is a part of WAL scheduler queue.
Add a test case.

Implement blueprint
https://blueprints.launchpad.net/tarantool/+spec/wal-mode-none

Add wal_mode = none setting.
It's possible to chagne wal_mode without restart.

When wal_mode = none, we don't write to WAL.
It's still possible to take a snapshot.

Replication and hot standby are currently not
operational in this mode.

A fix for bug https://bugs.launchpad.net/tarantool/+bug/790688
"ER_TUPLE_IS_RO should be more rare".

Rewrite the transaction processor to optimistically
perform changes in memory. In case of an error, transactions
are rolled back in order, reverse to the order of execution,
and gradually restore the original state of memory.
The wal writer therad orchestrates the rollback, by not
initiating it until all queries which entered the processing queue
before the error has occurred were not added to the rollback queue.

While in the state of rollback (i.e. collecting all requests
for rollback) new requests are not accepted into the processing
queue (see changes in wal_write()).

XXX: This patch makes dirty reads possible when we are in rollback,
since SELECTs do not enter the wal writer queue and can therefore
see changes which later will be rolled back. Since this is a
very rare situation, it's considered acceptable to fix this problem
in a separate patch (a separate bug will be reported).

Extract struct recovery_state members which are used
only when replication is on to struct remote.