[MAT-387] Use shared_ptrs for OGNumerics

Instead of using the PtrContainer<const OGNumeric*> for arguments
and registers within expressions, we now use an
std::vector<std::shared_ptr<const OGNumeric>> for the registers.

This is a very large change, and a summary of the changes follows:

This obsoletes the PtrContainer data structures, so they are
removed.

This also complicates the dispatch mechanism for dispatching to a
Java array of arrays, so the visitors that implemented this are
replaced with two new classes, Real16AoA and Complex16AoA. Their
implementation is considerably simpler than the old visitors.

The removal of the DispatchToOGTerminal visitor is also possible,
but has been left for a future ticket (MAT-407). This would also
simplify the code, but this PR contains enough changes already.

In this commit we add typedefs for shared_ptrs of each of the
types. In most places we switch to constructing objects wrapped by
these types. However, this is generally fiddly and unsafe, so in a
future commit we will replace this requirement with factory
methods for all of the nodes.

Also in this commit is a change to the Windows build, to increase
the stack size, which is required for the entrypt BigTree test to
pass (its stack is smaller than Linux and OS X by default). We
also need a linker flag that exports all symbols - all symbols are
exported by default, but it seems that the inclusion of shared_ptr
explicitly marks a method as exported, which changes the default
to not-exported. Therefore, we use this flag to force all symbols
to be exported.

Methods of OGNumeric subclasses sometimes need to pass themselves
to other methods. However, interfaces to these other methods
usually expect a shared_ptr, and the this pointer is a raw
pointer. In order to allow objects to find a shared_ptr to
themselves, we inherit from the standard library class
enable_shared_from_this so that shared_from_this() can be called
to obtain a suitable shared_ptr. shared_from_this() only works if
there is already a shared_ptr to this. This requires that whenever
an OGNumeric is constructed, it must be wrapped in a shared_ptr
for its methods to work.

One problem with needing shared_ptrs to pass to interfaces is in
the constructor of the FuzzyCompareOGTerminalContainer
constructor, which needs a shared_ptr to the object it points to.
However, because an OGTerminal's FuzzyCompareOGTerminalContainer
is created during construction, it is not possible to already have
a shared_ptr available. In order to work around this, the
FuzzyCompareOGTerminalContainer belonging to an OGTerminal is now
initialised lazily instead.

Because the OGTerminal holds reference to its own
FuzzyCompareOGTerminalContainer, it is also important that the
FCOGTC does not hold a shared_ptr to its OGTerminal, because then
it would be impossible to clean up any OGTerminal due to this
cyclic relationship. To avoid this, we use a weak_ptr in FCOGTC.

Many new/delete allocations that are not necessary are removed in
this commit.
[MAT-387] Replace typedefs with types in-class

Instead of typedefing shared_ptr<const OGNumeric> to pOGNumeric,
it is instead typedef'd to OGNumeric::Ptr.
[MAT-387] Make terminal constructors private

Since it is a requirement that every OGNumeric has a shared_ptr
that it can use for shared_from_this(), we don't want to allow the
construction of an OGNumeric with a "naked" new.

This commit makes all OGTerminal and subclasses constructors
private, and provides a static factory method create() for their
construction. The factory method returns a new OGTerminal wrapped
in a shared_ptr.

This still leaves OGExpr constrcutors exposed; this is addressed
in the next commit.
[MAT-387] Make Expr constructors private

This makes the remaining constructors for OGNumeric subclasses
private and provides factory methods for them.
[MAT-387] Remove methods that took raw pointers

This includes some methods from OGTerminal, and some iss methods.
[MAT-387] Add doc comments, remove dead code
[MAT-387] Use const refs where possible