os: Fix 64-bit Linux support.

ino_t and off_t types (d_ino and d_off fields) appear to be defined as unsigned
long on Linux.

TODO: Move readdir wrapper function to C, because DIRENT layout is inherently
OS-specific.
os: listdir(), walk(): Handle unicode strings properly.

CPython lib reference specifies that listdir() should accept both bytes and
str argument, and return value type should match the argument. But no such
stipulation is made for walk(), so we just return strings.
os: Version 0.1.9.
select: Add yet another workaround for struct epoll_event, this time for x86_64.

So, it's now clear that dealing with this struct should be rather moved on C side.
asyncio: Initial prototype implementation.
asyncio: Implement subclass implementing filedes watching interface.
asyncio: Recover eventloop's ability to work with callbacks.

Actually, coroutine support for call_soon() is a hack, in big asyncio coroutine
should be wrapped in Task object.
asyncio: Make run_forever() actually run forever.
asyncio: EpollEventLoop.wait(): support infinite wait.
asyncio: Support read/write syscalls, and route vals both ways between coros.
asyncio: Start adding asyncio stream interface.
asyncio: Add dumb debug output.
asyncio: Use logging and errno modules.
asyncio: Add remove_reader()/remove_writer().
asyncio: Add asyncio.async() dummy factory function.

Not Task bloat implemented (so far?), so just identity function for CPython
compatibility.
asyncio: Add basic loop.call_soon() test.
asyncio: Handle end of stream condition properly.

By removing any IO watches for associated file handle. The way it's
implemented tries to preserve OS-like separation between event loop and
tasks. So, stream to finish watching fd for IO also issues syscall,
instead of calling methods on loop instance directly. Calling method on
loop would be more efficient, but will require storing reference to loop
in each stream. And those separation matters...
asyncio: Add basic asyncio stream interface test.
asyncio_slow: Start new upstream API-compatible asyncio implementation.

The trait of this implementation is that it doesn't use priority queue and
time scheduling, and instead does its all operations using polling, starting
with such basic one as sleep. On the other hand, this tries to implement
all (well, much) of upstream asyncio API and warts.

asyncio_slow: Rename from asyncio_micro.

It may turn out that this won't be "micro" at all. The main trait of this
implementation is that it stay 100% API compatible with upstream (in
those APIs which are implemented of course). It will also keep inefficient
implementation of event loop scheduling, to discourage its use. Here we go.
asyncio_slow: Fix call_soon(), add call_later().