Added ElementResolver to resolve namespace conflicts in CBN (DNM, WIP)

@lukechurch please review this first cut implmentation. I would need @junmendoza to help me by providing the implementations of the core functions stubbed out below. These are mainly required by the `ElementResolver` to initially retrieve the fully resolved names from the compiler when there is no embedded information in the DYN file (i.e. when new code is typed in the CBN as well as migration of existing files). They are also needed to update the ASTs internally with the fully resolved class names via `IdentifierListNode's`, which would be eventually sent to the VM.

I need to implement embedding and reading of namespace information from DYN files. Currently I have added `TODO` placeholders for these calls. Also short name heuristics will come in subsequent submissions.

```
/// <summary>
        /// Get fully resolved name as identifier list from class table
        /// </summary>
        /// <param name="classTable"> class table in Core </param>
        /// <param name="partialNode"> partial class name as identifier/identifier list </param>
        /// <returns> fully resolved name as Identifier list </returns>
        private static IdentifierListNode GetResolvedClassName(ClassTable classTable, AssociativeNode partialNode)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Replace partial identifier with fully resolved identifier list in original AST
        /// This is the same AST that is also passed to the VM for execution
        /// </summary>
        /// <param name="astNode"></param>
        /// <param name="partialNode"> partial class name identifier </param>
        /// <param name="fullNode"> fully qualified class identifier list node </param>
        private static void ReplacePartialWithFullNode(ref AssociativeNode astNode, AssociativeNode partialNode, IdentifierListNode fullNode)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Find all partial class (Identifier/IdentifierListNode's) by performing a DFS traversal on input AST node
        /// </summary>
        /// <param name="astNode"> input AST node </param>
        /// <returns> list of IdentifierNode/IdentifierListNode of Class identifiers </returns>
        private static IEnumerable<AssociativeNode> GetClassIdentifiers(AST.Node astNode)
        {
            throw new NotImplementedException();
        }


        // Given an input fully resolved class name, convert it into an Identifier/IdentifierListNode
        private AssociativeNode InitializeNamespaceCache(string[] namespaceList)
        {
            throw new NotImplementedException();
        }
```

If possible I'd rather we do this without a cache unless the performance is really bad. Caching is a dangerous strategy, it makes the code harder to test, bugs harder to reproduce etc by introducing state where previously something was stateless.

Lets aim for a cache free design and see how we do.