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

### Overview ###
The objective here is to implement a strategy to handle namespace conflicts when there are multiple libraries loaded in Dynamo and to prevent breaking users' files as far as possible when they are opened in different Dynamo library environments. The approach here is to:
1. Embed (class => namespace) mapping information into the DYN file when saved
2. An `ElementResolver` object created when reading the file loads the information into its cache
3. At the pre-compilation stage of the CBN (post-parsing) the `ElementResolver` reads its cache and transforms the AST (obtained from parsing) by swapping its partial class names with the fully resolved names in the namespace cache. This happens in the `ResolveClassNamespace` method.
4. If no mapping is found in the cache, the `ElementResolver` updates its cache by relying on the compiler and `classTable` to resolve the namespace for a given partial class name. (If no unique class can be resolved, only then is a conflict warning generated for the user.)
5. The transformed AST containing the fully resolved class identifiers are later sent to the VM for execution. The idea here is to transform the ASTs internally and not having to drop long namespaces in user facing code
6. When the DYN file is saved, the updated cache in the `ElementResolver` is persisted to the file.

@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  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="partialName"> partial class name </param>
        /// <returns> fully resolved name as Identifier list </returns>
        private static string GetResolvedClassName(ClassTable classTable, string partialName);

        /// <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="partialName"> partial class name/identifier </param>
        /// <param name="resolvedName"> fully qualified classname </param>
        private static void ReplacePartialWithFullNode(ref AssociativeNode astNode, string partialName, string resolvedName);

        /// <summary>
        /// Find all partial class (Identifier/IdentifierLists) by performing a DFS traversal on input AST node
        /// </summary>
        /// <param name="astNode"> input AST node </param>
        /// <returns> list of IdentifierNode/IdentifierList of Class identifiers </returns>
        private static IEnumerable<string> GetClassIdentifiers(AST.Node astNode);


        // Given an input fully resolved class name, convert it into an Identifier/IdentifierListNode
        private void InitializeNamespaceCache(string[] namespaceList);
```

The cache is mainly used to hold namespace mapping data read from the DYN file, in memory, so that it can be used by the element resolver to perform class resolution, and/or updated and persisted back to the DYN file upon saving.