Changed distance(Positional) to distance(Position)

distance(Positional) is now a non-virtual method that simply calls
distance(Position), and distance(Position) gets overridden by
WrappedPositional.

This allows for the nicer posagent.distance(pos) notation.
Positional doc fixes: 'agent' -> 'object'

Since Positional inherits through templating and thus isn't tied to
Agent anymore.
Made transferApprox non-const-ref in amount

This allows a.transferApprox(a, b) to transfer everything away.
Before, it's not entirely clear that this would be reliable since
`amount`, being a reference to *this, is changing.
Added missing code for recent distance() change
Added original type tracking.

This allows looser restrictions on the copy assignment operator: in
particular, it means you're now allowed to assign one SharedMember to
another *if* the *original* type of the two SharedMembers is the same.
In other words, if a and b are both SharedMember<Derived>, and Derived
inherits from Base, and am and bm are a and b cast into
SharedMember<Member>, then any of a = b, am = bm, am = b, and a = bm are
allowed (the latter two via an implicit cast constructor).

If c comes along which is originally a SharedMember<Derived2> (where
Derived2 is derived from Derived), then any attempt to assign between a
and c or b and c will fail, *regardless* of what SharedMember<T> c gets
cast into.  Even if SharedMember<Derived> cd{c} is created, cd is still
not interchangeable with a/am/b/bm because the original type differs.

In practice, this allows code such as:

    SharedMember<T> best;
    for (auto t : simulation()->agents<T>()) {
        if (!best.ptr() or t.better_than(best)) {
            best = t;
        }
    }

as long as T is a specific type (and not a base class that catches
other derived classes).

It also allow random shuffling via

    std::vector<SharedAgent<T>> v = ...;
    std::shuffle(v.begin(), v.end(), Random::rng());

(subject to the same caveat that everything in the vector must be an
instance of exactly the same class) which wasn't allowed before because
of the inability to copy.
null pointers more acceptable: eris_id_t returns 0

Previously casting to an eris_id_t was an deference failure on a null
object, but now `if (shared)` is useful for checking both whether it's
null and whether it's in a simulation.

Updated documentation to note that the null pointer usage is more
acceptable now.

Removed the rvalue constructor: all it was doing was calling the copy
constructor anyway, which the compiler is smart enough to do on its own.
Added scratch script for playing with SharedMember