Now at least type param lists don't break the font locking of later
param lists in the signature.

This involves a new anchored matcher to iterate over each
param in the list.

This uses a cheeky approach where we piggyback off existing type
matching. After using the existing matcher to fontify "foo" in
make(foo[bar]), we then check if the next char is "[", and if so we
know it is a type list, so we fontify it as such.

This approach will be used in later commits for all the other simple
type matchers.

When fontifying a type list if we see another "[" we presume it is a
nested type list and fontify it accordingly.

Now we fontify func names in generic invocations when there are more
than one type params (so we can be sure it is a func instantiation).

I also tweaked things to avoid fontifying "bar"
in (foo)(bar)(baz) (fixes dominikh#385).

We also support fontifying method names with type params even though
that isn't allowed yet.

For example, we now fontify a, b, c and d as types:

    map[a[b]]c[d]

This required tweaking the map value matcher to allow square brackets
to appear in the map key type.

Fix "foo.Bar", "int" and "string" are now fontified as types in
"foo.Bar[int, string]{}".

We now fontify "foo" and "bar" as types in:

    []foo[bar]

We now fontify "baz" as a type:

   type foo = bar[baz]

"bar" is now fontified as a type in:

    func _() foo[bar] {}

    var _ foo[bar]

If there is more than one thing in between "[]", we know it is a type
list.

Now we fontify "int" and "string" as types in:

    foo[int, string]()