- Fix some local variable names
- Change CORD_ON_EXIT_WONT_RUN definition; upper case is for macro
- Bring back sanity check for spurious wakeup in cord_cojoin
- Similar changes in coeio for consistency

- fix a coding bug/regression in fiber.cc with wrong
  check of result of the dynamic cast
- style fixes
- fix initialization of type objects
  when some members of inheritance hierarchy were
  excluded from type hierarchy

Implement rtti-like scheme to export C++ type information to FFI.

Extract Exception::clear(), Exception::move(), fiber()->exception
into struct diag methods. This refactoring makes desired logic
to be more clear.

Rename global `fiber` into `fiber_ptr` (for use with gdb and avoidance of ambiguity with `struct fiber`)

Don't log exceptions of dead joinable fibers - it will
be logged by the caller, so avoid double logging.

recover_remaining_wals() is now more like an iterator,
vclockset_match() is only called when there is no current WAL.

Add a test case for gaps in LSNs.

*) Splitted rlist initializer to RLIST_HEAD_INITIALIZER(..) and RTREE_LINK_INITIALIZER

* implement two new calls:
  box.error.last() - returns last error, if any, as a Lua table
  box.error.clear() - clears the last error

* add an alias for box.error(), box.error.raise()

If a fiber becomes ready on a user-defined event, schedule it
in the same event loop, not in the next loop, to save one epoll_wait()
invocation in cases when something is added to a fiber channel,
and there is a fiber ready for execution waiting on the channel.

Add a micro-bench to the unit test suite.

Change fiber_sleep(0) implementation to use fiber_wakeup().
Implement a more fair scheduling for "ready" fibers: they are
scheduled in the next event loop iteration, not in the same.

Don't try to rename an .inprogrss file in recovery_finalize(): if
recovery_finalize() can't open it, then xdir_scan() must have
failed to open it as well, then the file can't end up in the index
in the first place.

Don't try to re-read a file 3 times (good number, eh), since this
looks like chasing a ghost. If the original cause for these
lines of code (lost) is still relevant, then a different fix will
be necessary.

The original code was apparently trying to cope with a potential
race condition between local hot standby/replication relay and WAL
writer, where WAL writer thread first creates a new WAL file, and
only aft that closes the previous one, while local hot standby
scans the directory, and then reads all files which it finds in
the directory.

Apparently, the author of the code believed that some data in the
file may not be visible to the reader process after it was written
by the writer process, and the reader could skip this data and
switch to the next file. The switch can not be postponed, since,
when reading the file, it's impossible to know whether it's an old
corrupted file or a new one.

Remove the code, since, according to Linux man page:

POSIX requires that a read(2) which can be proved to occur after a
write() has returned returns the new data. Note that not all
filesystems are POSIX conforming.

POSIX says:

Writes can be serialized with respect to other reads and writes.
If a read of file data can be proven (by any means) to occur after
a write() of the data, it must reflect that write(), even if the
calls are made by differen processes. A similar requirement
applies to multiple write operations to t same file position. This
is needed to guarantee the propagation of data fr write() calls to
subsequent read() calls. This requirement is particularly
significant for networked file systems, where some caching schemes
violate these semantics.

Note that this is specified in terms of read() and write(). The
XSI extensions readv() and writev() also obey these semantics. A
new "high-performance" write analog that did not follow these
serialization requirements would also be permitted by this
wording. This volume of IEEE 1003.1-2001 is also silent about any
effects of application-level caching (such as that done by stdio).

Reorder the events in wal_opt_rotate(): first close the old file,
and only then open a new one.

Fix a bug in replication that didn't take into account wal_dir_rescan_delay.
This fix revealed a number of serious races in recovery_follow_f,
which will be addressed separately.

Rewrite replication to use cooperative I/O.
Propagate replication exceptions to the main thread.
Introduce a function which stats a thread with a running
event machine in it.

Fix a few bugs related to destruction of resources allocated in a
non-main thread.

Remove replication_prefork() and all the code related to pushing
a socket into another process.
Add debug asserts to slab cache, to ensure it's used from a single
thread only.

Add replication status to box.info().
When replication is off, box.info.replication.status is 'off'.
Other allowed statuses are:
    - 'connecting' - trying to connect to the master
    - 'connected' - connected, but nothing read yet,
    - 'running' - successfully received first rows
    - 'failed' - network error
    - 'stopped' - apply conflict, replication needs to be restarted

Move recovery_last_update and recovery_delay to section 'replication'
in box.info(), replace the first with 'lag' variable, indicating
the time difference between the currnet time and row time of the last
row, and 'idle' variable, indicating the difference between the
current time and the time of last event from the master.

Also output the text of the last error when it happens and
stops replication.

Make vclock output in box.info more compact.

Remove 'sophia' section from box.info, it's big, and we need
to solve the problem of status systematically for all engines.

Fix crashes when trying to stop failed replication: fiber_cancel()
of a dead cancellable fiber would try to schedule it and crash.

Add a test case.
Rename fiber.test to fiber_stress.test
Change cxception propagation so that exception is fiber-local,
not thread local.
Added exception propagation to fiber_join().

Rename fiber_zombificate() to fiber_recycle().
Don't double-initialize same members of the fibers.
Introduce a function which contains common initialization
of fiber_new() and fiber_recycle().
Use a common naming scheme for lists of dead, alive and ready
fibers in a cord.

Remove explicit fiber call stack from the cord.

Fix backtrace() to work correclty with an optimized (-O2) build.

1)Added 'slab_alloc_maximal' config option.
2)Tuple slab cache is creating now with a range of orders depends on
  'slab_alloc_minimal' and 'slab_alloc_maximal' config options.
3)Smallocator's mempools now selects proper order of slab depends on
   size of an object.
4)after CR fixes

Explicitly mark places which are unsafe for cancel.

Everything is cancellable. In fiber_cancel() use fiber_wakeup()
instead of a direct call. This make cancel safe with
regards to wakeup() and timeouts: i.e. it's safe to cancel
a fiber which is waiting on a timeout or is about to get
scheduled.

Avoid an unnecessary interlocked instruction or pipe write
in fiber_wakeup(), it's always called from the same cord
as the one to which the event loop belongs.

Use ev_feed_event() with EV_CUSTOM instead.

Unit test coio_stat.

Cleanup unit tests a bit: merge unit.h and test.h, which
would duplicate each other.

Fix a bug in trigger_atexit.test, which would not clean up after
itself.

libcore is a thick a thick bundle with almost everything.
Rename it to libserver.

Extract the minimal server core with fibers & exceptions into libcore.

Add a prototype unit test for fibers.

Fix obvious coding bugs in cord_cojoin/cord_join().

Remove unnecessary constants & arguments.
Keep an eye on the include dependencies becoming more messy.
Clear the O_NONBLOCK flag in the join thread, which
uses non-blocking API.
Suspend I/O in the main thread event loop for the
duration of replication join/subscribe.

Other changes:

 * Saving/re-throwing original exception caused cord to terminate