Add a public "MatchPriority" class that defines 2 possible values.

* Convert the ICompletionProvider interface to a CompletionListProvider abstract class.
* Rename CompletionItemGroup to CompletionList
* Introduce a CompletionListContext type to be used by providers to specify the contents and
  details of CompletionLists with a RegisterCompletionListAsync() method.
* Change GetGroupsAsync() method to GetCompletionListAsync(), which returns Task<CompletionList> rather
  than Task<IEnumerable<CompletionList>>.
* Move code that merges, de-dupes and sorts completion lists from the controller into the
  completion service. This affected a few VB spell check unit tests which now change their ordering
  slightly.

Currently, the C# and VB suggestion mode completion providers both implement ICompletionProvider
in nearly the same way. This change introduces a new base class containing the shared
implementations.

Note: prior to this change, C# and VB returned different values for IsCommitCharacter: false and
true respectively. Now they'll both return false. However, this is OK because the completion
controller handles builder completion items specially and IsCommitCharacter so that is never
actually called in this case.

There is a special completion list provider in VB for showing completions within Inherits or Implements
statements. This change removes that customer completion list provider and pushes its logic down into
the recommendation service. That way the Recommender API will correctly return these symbols, and the
symbol completion provider will service them up into the completion list.

Because the Implements/Inherits completion list provider produced an exclusive lists, a small tweak needs
to be made to the built-in type keyword recommender. Otherwise, keywords like 'Boolean' would be recommended
after Inherits, which isn't legal. Additionally, I've added a unit test to verify that 'Global' **does**
show up after Inherits and Implements.

Now that the comment formatting issue is fixed in the Formatter type, we can run the formatter on the remainder of the VB code base.

closes #1424

Previously, the way one used a patter matcher was the following:

    var matcher = new PatternMatcher();
    Loop {
        var result = matcher.MatchPattern(candidate, pattern)
    }

Because of this, each time you called MatchPattern, the matcher would have to deconstruct the
pattern into its relevant components (for example, splitting it on dots and decomposing words out
of it).  Now, this decomposition was cached.  However, that still meant checking the cache on each
call to MatchPattern.  This check involved a lock as well as a dictionary lookup.

The new way to use a pattern matcher is:

    var matcher = new PatternMatcher(pattern);
    Loop {
        var result = matcher.MatchPattern(candidate)
    }

This approach means that we only need to decompose the pattern once.  From then on we can reuse
that decomposition for each value we test against.