msgpack_rpc: Deal with deserialization failures

There seems to be no way to deal with failures when calling
`msgpack_unpacker_next`, so this reimplements that function as
`msgpack_rpc_unpack`, which has an additional result for detecting failures.

On top of that, we make use of the new function to properly return msgpack-rpc
errors when something bad happens.
wstream: Change wstream_write failure behavior

Before this change, any write that could cause a WStream instance to use more
than `maxmem` would fail, which is not acceptable when writing big chunks of
data. (This could happen when returning contents from a big buffer through the
API, for example).

Writes of any size are now allowed, but before we check if the currently used
memory doesn't break the limit. This should be enough to prevent us from
stacking data when talking to a locked process.
wstream: Refactor wstream_new_buffer/wstream_write

- Removed 'copy' parameter from `wstream_new_buffer`. Callers simply pass a
  copy of the buffer if required.
- Added a callback parameter, which is used to notify callers when the data is
  successfully written. The callback is also used to free the buffer(if
  required) and is compatible with `free` from the standard library.
rstream: Rename RStream `async` flag to `defer`

The name `async` was not appropriate to describe the behavior enabled by the
flag.
rstream: Implement the rstream_set_defer function

This function will be used to temporarily change the `defer` flag on rstream
instances.
job: Refactor to use pointers instead of ids

'job_start' returns the id as an out paramter, and the 'job_find' function is
now used by eval.c to translate job ids into pointers.
job: Add defer flag and setter method

This is has the same effect as the RStream 'defer' flag, but also works for the
job's exit event.
job: Refactor job_write to receive WBuffer instances.

This was done to give more control over memory management to job_write callers.
channel: Make channel_{un}subscribe abort the program for invalid ids

These functions will never be called directly by the user so bugs are the only
reason for passing invalid channel ids. Instead of returning silently we abort
to improve bug detection.
events: Refactor event_poll to use stack-allocated timer handles
events: Refactor how events are queued for processing

To make it possible reuse `event_poll` recursively and in other blocking
function calls, this changes how deferred/immediate events are processed:

- There are two queues in event.c, one for immediate events and another for
  deferred events. The queue used when pushing/processing events is determined
  with boolean arguments passed to `event_push`/`event_process` respectively.
- Events pushed to the immediate queue are processed inside `event_poll` but
  after the `uv_run` call. This is required because libuv event loop does not
  support recursion, and processing events may result in other `event_poll`
  calls.
- Events pushed to the deferred queue are processed later by calling
  `event_process(true)`. This is required to "trick" vim into treating all
  asynchronous events as special keypresses, which is the least obtrusive
  way of introducing asynchronicity into the editor.
- RStream instances will now forward the `defer` flag to the `event_push` call.
build: Fix error in dispatch generator for functions with channel_id
build: increase timeout for run-api-tests.exp
api: Rename find_{buffer,window,tabpage}

They were renamed to find_{buffer,window,tabpage}_by_handle to avoid conflicts
with existing functions of the same name.
api: Change type of event data to `Object` from `typval_T`
api: Enable usage of Arrays and Dictionaries as [k]vectors

- Rename a/n/m to items/size/capactity in kvec.h
- Add capactity field to Arrays/Dictionaries
api: Add helper macros for dealing with API type casts
Merge PR #853