Simplify class and module grammar for more consistency

[vinistock]

Motivation

One tiny thing that bothered me with the syntax highlighting is that our grammar incorrectly considered the :: separator as part of a class/module declaration, highlighting the entire thing in the same colour. This PR fixes that by simplifying the grammar regex.

Implementation

I simplified the regex in the grammar. There are things it was trying to account for that were unnecessary. For example, it tried to handle any arbitrary number of line breaks between the class keyword and the constant name (which TIL is valid Ruby). That's not necessary because semantic highlighting will catch that constant for us.

Another example is that it included trying to parse a parent class for modules, which is not valid Ruby module Foo < Bar.

We also don't need to account for syntax errors since those are already provided by the server. The summary is: we can make these regexes much simpler and easier to understand.

The way the grammar works is:

1. Write a regex in the match attribute
2. Define what highlight token should be assigned to each regex capture group

[andyw8]

What do you think about adding some tests (in Ruby) which read the JSON, extract the regexps, and perform some checks?

[vinistock]

@andyw8 I think that's a great idea and necessary in the long run to maintain these grammar files in a healthy way. The Ruby one is huge and understanding all regexes is no easy task.

However, I'd prefer leaving that to a separate task. VS Code doesn't provide an easy way to test grammar files as far as I know. We will need to explore building a test framework that applies the grammar rules to a string of Ruby code and then allows us to assert the token types for every position. It's bound to take a little bit of effort to get right. I created #2249 so that we don't forget.

[andyw8]

For illustration:

s = "class Namespace::ClassName < OtherNamespace::OtherClassName"
re_old = "(?x)\n^\\s*(class)\\s+\n(\n  (\n    [.a-zA-Z0-9_:]+\n    (\\s*(<)\\s*[.a-zA-Z0-9_:]+)?   # class A < B\n 
 )\n  |\n  ((<<)\\s*[.a-zA-Z0-9_:]+)         # class << C\n)"
s.match(re_old)
=> 
#<MatchData
 "class Namespace::ClassName < OtherNamespace::OtherClassName"
 1:"class"
 2:"Namespace::ClassName < OtherNamespace::OtherClassName"
 3:"Namespace::ClassName < OtherNamespace::OtherClassName"
 4:" < OtherNamespace::OtherClassName"
 5:"<"
 6:nil
 7:nil>

re_new = "(class)\\s*(([a-zA-Z0-9_]+)((::)[a-zA-Z0-9_]+)*)\\s*((<)\\s*(([a-zA-Z0-9_]+)((::)[a-zA-Z0-9_]+)*))?"
s.match(re_new)
=> 
#<MatchData
 "class Namespace::ClassName < OtherNamespace::OtherClassName"
 1:"class"
 2:"Namespace::ClassName"
 3:"Namespace"
 4:"::ClassName"
 5:"::"
 6:"< OtherNamespace::OtherClassName"
 7:"<"
 8:"OtherNamespace::OtherClassName"
 9:"OtherNamespace"
 10:"::OtherClassName"
 11:"::">