Spead2

- Fix bug causing some log messages to be remapped to DEBUG level

- Increase log level for packet rejection from DEBUG to INFO

- Some minor optimisations

- Handle heaps that have out-of-range item offsets without crashing (32)

- Fix handling of heaps without heap length headers

- :py:meth:`spead2.send.UdpStream.send_heap` now correctly raises
:py:exc:`IOError` if the heap is rejected due to being full, or if there was
an OS-level error in sending the heap.

- Fix :py:meth:`spead2.send.trollius.UdpStream.async_send_heap` for the case
where the last sent heap failed.

- Use :manpage:`eventfd(2)` for semaphores on Linux, which makes a very small
improvement in ringbuffer performance.

- Prevent messages about descriptor replacements for descriptor reissues with
no change.

- Fix a use-after-free bug (affecting Python only).

- Throw :py:exc:`OverflowError` on out-of-range UDP port number, instead of
wrapping.

- Fix compilation on systems without glibc

- Fix test suite for non-Linux systems

- Add :py:meth:`spead2.send.trollius.UdpStream.async_flush`

- Add C++ version of spead2_recv, a more fully-featured alternative to test_recv

- **backwards-incompatible change**:
Add `ring_heaps` parameter to :cpp:class:`~spead2::recv::ring_stream`
constructor. Code that specifies the
`contiguous_only` parameter will need to be
modified since the position has changed. Python code is unaffected.

- Increased the default for `ring_heaps` from 2 (previously hardcoded) to 4 to
improve throughput for small heaps.

- Add support for user to provide the socket for UDP communications. This
allows socket options to be set by the user, for example, to configure
multicast.

- Force numpy>=1.9.2 to avoid a numpy [bug](https://github.com/numpy/numpy/issues/5356).

- Add experimental support for receiving packets via netmap

- Improved receive performance on Linux, particularly for small packets, using
[recvmmsg](http://linux.die.net/man/2/recvmmsg).

- Enforce ASCII encoding on descriptor fields.

- Warn if a heap is dropped due to being incomplete.

- Add --ring option to C++ spead2_bench to test ringbuffer performance.

- Reading from a memory buffer (e.g. with
:py:func:`~spead2.recv.Stream.add_buffer_reader`) is now reliable, instead of
dropping heaps if the consumer doesn't keep up (heaps can still be dropped if
packets extracted from the buffer are out-of-order, but it is
deterministic).

- The receive ringbuffer now has a fixed size (2), and pushes are blocking. The
result is lower memory usage, and it is no longer necessary to pass a large
`max_heaps` value to deal with the consumer not always keeping up. Instead,
it may be necessary to increase the socket buffer size.

- **backwards-incompatible change**:
Calling :cpp:func:`spead2::recv::ring_stream::stop` now discards remaining
partial heaps instead of adding them to the ringbuffer. This only affects the
C++ API, because the Python API does not provide any access to partial heaps
anyway.

- **backwards-incompatible change**:
A heap with a stop flag is swallowed rather than passed to
:cpp:func:`~spead2::recv::stream::heap_ready` (see issue
[29](https://github.com/ska-sa/spead2/issues/29)).