Lowest memory address is zero

Stacks grow upwards etc. In particular, for a statically allocated
array xs with N elements of type T, the following statement is true:

  for all n < N : xs[n].addr() == xs.addr() + sizeof(T) * n
Use DeclVar<T[N]>::addr() for variable

Unless an array is decayed, it cannot be an lvalue, i.e. assignments to
it are forbidden. Of course, assignments to individual array elements
are still allowed.
Distinguish MemoryAddr::alloc<T>(_, N) and MemoryAddr::alloc<T[N]>()

* MemoryAddr::alloc<T>(_, N) is a disjunction of possible memory addresses
* MemoryAddr::alloc<T[N]>() is the base address of the fixed-size array
* SingletonMemoryAddr class type checks that ptrs().size() == 1
Track base address for arrays
Delete deprecated function
Document the source of read events in blocks
Add MemoryAddrRelation<T>::event_ptrs()

Return an std::unordered_set of all event pointers that were passed to
MemoryAddrRelation<T>::relate(). These pointers allow the Encoder to
relate events when MemoryAddrRelation<T>::partition() is not applicable.
Treat MemoryAddr as a lattice element

The treatment of MemoryAddr as elements in a lattice means that these
are partially ordered. Denote this partial order by <=. Let a and a' be
MemoryAddr objects. Let e and e' be events such that e.addr() == a and
e'.addr() == a'. Informally, a <= a' iff e' affects less memory than e.

Changes:

* Add MemoryAddr::meet(const MemoryAddr&) and join(const MemoryAddr&)
* Deprecate static MemoryAddr::join(const MemoryAddr&, const MemoryAddr&)
Change Event encoder dispatcher functions

* Rename Event::encode(const Z3ValueEncoder&, Z3&) to Event::encode_eq(...)
* Add Event::constant(Z3&)

The new dispatcher function Event::constant(Z3&) is needed to allow the
Encoder create an appropriate Z3 constant from a given event as this is
often not possible by merely inspecting Event::type().

To see this, consider IndirectWriteEvent<Range, Domain, N> where Range
could be an integral type. While Event::type() captures the Range type
attributes of the memory being indirectly written, the event must be
encoded as an array constant. A similar example is ReadEvent<T[N]> that
is also encoded as an array constant.
Encode shared array accesses

* Ensure Encoder only links up shared memory events
* Allow conversions of SharedMemory rvalue references
* Extract read events from DerefReadInstr when recording an indirect write
* Fix RF encoding algorithm for shared array accesses:
  - Use Event::constant(Z3&) because Event::type() does not give enough
    information about events such as IndirectWriteEvent etc.
  - Use MemoryAddrRelation::event_ptrs(), MemoryAddr::meet(...) and
    MemoryAddr::is_bottom() to detect when events should be linked up

Currently, the is_bottom() check in RF assumes that if is_bottom() is
false, then the type of both events are compatible in Z3. This is likely
to require further work.