introduce shared_ptr for AST nodes

[bcumming]

Currently Expressions are created as raw pointers, and never deleted. In practice this works fine, and we are never likely to run out of memory. However, as the application scales, this approach might not scale. It is also just bad practice.

• replace all naked pointers with std::shared_ptr.
• this will be quite a big changes (it can't be done in stages): it is all or nothing.
• start working on unit tests for small expressions, and scale up until we have the entire AST covered.

[bcumming]

I have started a pointers branch for this.

• using std::shared_ptr removed all memory leaks for the parsing (un-annotated AST generation)
• there are circular references in the annotated AST, caused by shared pointers in the symbol table referring to function and procedure calls that then refer back into the symbol table.

The next step is to take a step back, and resolve ownership of things in the symbol table.

• I am starting to have reservations about my gratuitous use of shared_ptr
• I will try to fix the current issues with circular references
• then consider if this is a good design (I suspect not)

[bcumming]

fixed in the merge of the ast branch. The unit tests and the compiler now pass valgrind with zero memory leaks.

The fix used std::unique_ptr to manage ownership of AST nodes and symbols. Each node is stored in the AST using a unique_ptr. Symbols are stored in the symbol tables using unique pointers, and all references to a symbol from the AST (formed during semantic analysis) are raw pointers. This fixed some complexities of the original approach, by ensuring that Symbols are only created in the symbol tables, and that it is much more difficult to accidentally create two symbols twice.