Add ability to compile a pattern

[lukemassa]

What

Add ability to compile a Pattern once and use it for subsequent matches.

Note this is currently a naive implementation that just calls the existing Match(), I wanted to firstly gauge interest of the maintainers to see if this is a feature worth implementing, and also to discuss what the various exported identifiers should be.

Why

ValidatePattern(), allows the user to inspect whether there is an error before saving the pattern for later. This goes a step further, and removes the error from the analogous Match() function, since it cannot fail once compiled, making it a bit cleaner to use.

Additionally, presumably a compiled pattern could be made to be more efficient, though I haven't dug into the implementation there yet. My naive implementation is very slightly better than Match(), since it makes use of the existing MatchUnvalidated, which skips some validation and therefore saves time.

I modeled the methods and signatures after regexp in go's standard library (quoted in part here):

func MatchString(pattern string, s string) (matched bool, err error)
type Regexp struct{ ... }
    func Compile(expr string) (*Regexp, error)
    func MustCompile(str string) *Regexp
    func (re *Regexp) Match(s string) bool

https://pkg.go.dev/regexp

Usage

    pattern, err := doublestar.Compile("foo/*")
    if err != nil {
        log.Fatal(err)
    }
    if pattern.Match("foo/bar") {
        fmt.Println("Pattern matches foo/bar")
    }
    if pattern.Match("bar/foo") {
        fmt.Println("Pattern matches bar/foo")
    }
    
    // Prints "Pattern matches foo/bar"

Testing

The compiled version is run through the same suite of tests as the normal version, which also serves to make sure they are in lock-step.

References

Closes: #85