There's little point in doing the priority override most of the time, so
this splits the two and only uses the full priority-overriding glue
class if the class actually has a ..._priority method; otherwise a
simpler class that doesn't override priority is used.

Switched to pybind's `hasattr` method rather than the now-deprecated
`.attr()`-in-bool-context code.

Without implicit cpp conversion this is needed to allow `Bundle(good,
123)` where `good` is a Good object, rather than just an id.

It won't be merged upstream, so work around it for `remove()` by
providing two: one that takes a Member, one that takes an id.

Change submodule to upstream pybind11 instead of my own repository;
all of my PRs except for the C++ implicit conversion is already
upstream.

Stop using deprecated py::base in favour of specifying base class in the
template args.

Remove unnecessary std::unique_ptr holder specifiers

Rebased on latest upstream with my PR branches applied.

Since we require numpy anyway (for learning support), there's little
point in exposing this here.

Removed items were being destroyed before _remove was called, which
meant that _remove was never called (because the object no longer
existed).

This puts the overload handler in its own function (because
PYBIND11_OVERLOAD* does a return), calls it, *then* does the
`dec_ref()`.

This maps eris::single_peak_search, and also provides a std::nextafter
wrapper (since python's math class doesn't have one).

It doesn't do anything; any method that can be overridden is already
virtual.

The C++ eris interface returns the ids for performance reasons; the
python interface isn't so concerned with that, so just do agent lookups
and return a python set of all the actual firms.

Merged upstream/master, which now includes the (pyeris-crucial)
trampoline overload lookup fix.

Simulation.RunStage.intra_begin was tedious to write, so export
RunStage directly in eris instead.

The trampoline class is never actually instantiated, it is only used
for it's methods.  The Firm trampoline was trying to expose the stored
bundles by copying a reference into the trampoline class, but for the
aforementioned reason this won't work.

Instead expose the protected fields via getter/setter methods.

They return a Bundle& instead of BundleSigned&

max_threads isn't tested and probably doesn't work (to work it would
need mucking around with python's GIL, which is a beast and makes
threading in python sort of suck).  For now just comment it out.

Also symlink tests/eris and scratch/eris to build/eris for the same
reason.

Trampoline inheritance is something of a nuissance because all of the
base class methods need to be repeated.  I was doing this with some
defines that shoehorned common methods into each Member subclass, but
that was messy.

This approach (using "Curiously Recursive Templates") is nicer: each
PyWhatever class is templated with its base class, so that
PyFirmNoProd<FirmNoProd> ends up with inheritance path:

    PyFirmNoProd<FirmNoProd> : PyFirm<FirmNoProd> : PyAgent<FirmNoProd> :
    PyMember<FirmNoProd> : FirmNoProd : Firm : Agent : Member

This is still a lot of duplication, but it's mainly at the compiler
level which makes maintenance easier and keeps the code a bit cleaner.