Enhancements for Neovim

This PR contains some enhancements that will make YCM run better on Neovim, which uses a separate process for running python code.

Here's a summary of the changes:

- Calls to the magic vim module have been reduced in order to lower the communication overhead between the python process and Neovim(It won't impact vim performance)
- A new class which is automatically loaded by the python process(NvimYcmAsyncHelper) was added. This class handles events from Neovim and callbacks from ycmd requests.
- Neovim `send_event` function is used to notify the python process about events. This was done because the `python` command blocks Neovim until the python process responds.
- Instead of polling for compilation/completion results, NvimYcmAsyncHelper directly calls Neovim once ycmd responds. For Neovim, the `complete()` vimscript is used to display completions asynchronously('omnifunc' is not touched)

I've posted this for review, but it's not ready for merging yet. I'm still stabilizing the Neovim branch which supports python plugins, so there may be some minor changes to this code. I'm also going to improve commit messages and descriptions.
Most of the Neovim-specific performance issues are fixed by the first commit of this PR, the same which moves request building code to vimscript. This didn't match with my initial assumptions that the cause was the amount of data being transfered for each event, so I did some profiling to get to the real problem.

It seems the slowdown is caused by the synchronization code I added to support multithreading in the python client, not by IPC overhead. Here's the profiler output for this PR

```
         209630 function calls (205655 primitive calls) in 1.343 seconds

   Ordered by: internal time
   List reduced from 1388 to 30 due to restriction <30>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
      268    0.831    0.003    0.834    0.003 {method 'run' of 'pyuv.Loop' objects}
       26    0.057    0.002    0.092    0.004 {method 'sub' of '_sre.SRE_Pattern' objects}
      509    0.049    0.000    0.049    0.000 {method 'acquire' of 'thread.lock' objects}
    46272    0.028    0.000    0.034    0.000 encoder.py:37(replace)
      132    0.022    0.000    0.022    0.000 {method 'write' of 'pyuv.Stream' objects}
      228    0.018    0.000    0.051    0.000 posixpath.py:372(_joinrealpath)
     1856    0.016    0.000    0.016    0.000 {posix.lstat}
     2121    0.013    0.000    0.013    0.000 {method 'search' of '_sre.SRE_Pattern' objects}
        2    0.013    0.006    0.013    0.006 {method 'connect' of '_socket.socket' objects}
     2567    0.009    0.000    0.009    0.000 {method 'startswith' of 'unicode' objects}
```

and here for the master branch:

```
         10214073 function calls (10038486 primitive calls) in 16.478 seconds

   Ordered by: internal time
   List reduced from 1400 to 30 due to restriction <30>

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
   114443    2.587    0.000    3.680    0.000 {method 'run' of 'pyuv.Loop' objects}
   114404    1.243    0.000    5.840    0.000 client.py:124(unpack_message)
   917638    0.845    0.000    0.845    0.000 __init__.py:1329(getEffectiveLevel)
    57458    0.792    0.000   10.812    0.000 client.py:25(wait)
   917638    0.772    0.000    1.618    0.000 __init__.py:1343(isEnabledFor)
171862/41    0.733    0.000   16.247    0.396 client.py:207(invoke_message_cb)
   229320    0.658    0.000    2.204    0.000 client.py:90(release)
   917637    0.609    0.000    2.226    0.000 __init__.py:1128(debug)
    57458    0.578    0.000    4.215    0.000 client.py:174(msgpack_rpc_request)
   229320    0.544    0.000    0.963    0.000 client.py:83(acquire)
   171349    0.503    0.000    4.541    0.000 uv_stream.py:123(_run)
   229335    0.405    0.000    0.760    0.000 threading.py:372(notify)
    57498    0.397    0.000    0.397    0.000 {method 'write' of 'pyuv.Stream' objects}
    57458    0.385    0.000    4.787    0.000 client.py:324(async_func)
   114404    0.384    0.000    6.270    0.000 client.py:162(queue_message)
    57497    0.320    0.000    0.613    0.000 uv_stream.py:76(_on_read)
   458641    0.307    0.000    0.403    0.000 threading.py:287(__exit__)
   458641    0.285    0.000    0.498    0.000 threading.py:284(__enter__)
    57498    0.279    0.000    2.147    0.000 uv_stream.py:177(write)
   229320    0.247    0.000    1.063    0.000 threading.py:399(notifyAll)
   114404    0.229    0.000    3.487    0.000 uv_stream.py:157(read)
   458640    0.213    0.000    0.213    0.000 {method '__enter__' of 'thread.lock' objects}
   172273    0.207    0.000    0.207    0.000 {hasattr}
   229339    0.174    0.000    0.280    0.000 threading.py:299(_is_owned)
   229320    0.172    0.000    1.136    0.000 client.py:95(__enter__)
    57497    0.164    0.000    0.164    0.000 client.py:41(__init__)
   229320    0.152    0.000    2.356    0.000 client.py:98(__exit__)
    57458    0.147    0.000    0.147    0.000 client.py:12(__init__)
    57498    0.146    0.000    0.266    0.000 __init__.py:41(packb)
    57458    0.128    0.000   15.727    0.000 client.py:339(func)
```

All I did was open nvim with a 20k loc C file

I bet YCM will run much better once I reimplement the client it using greenlets + twisted, which I was already planning to do.

In case you are wondering, I've posted the profiler output here because it may be interesting to you, considering that ycmd is implemented as a multithreaded python web server(the performance may improve if requests are served with green threads)