Add specific error type (NotSupportedError) when parsing not supported sentence

Example:
```go
var notSupportedErr *nmea.NotSupportedError
if errors.As(err, &notSupportedErr) {
	fmt.Printf("Prefix %s is not supported\n", notSupportedErr.Prefix)
}
```

Author: aldas

README.md

@@ -193,16 +193,16 @@ func main() {
 		panic(err)
 	}
 
-	m, ok := s.(XYZType)
-	if !ok {
-		panic("Could not parse type XYZ")
+	switch m := s.(type) {
+	case XYZType:
+		fmt.Printf("Raw sentence: %v\n", m)
+		fmt.Printf("Time: %s\n", m.Time)
+		fmt.Printf("Label: %s\n", m.Label)
+		fmt.Printf("Counter: %d\n", m.Counter)
+		fmt.Printf("Value: %f\n", m.Value)
+	default:
+		panic("Could not parse XYZ sentence")
 	}
-
-	fmt.Printf("Raw sentence: %v\n", m)
-	fmt.Printf("Time: %s\n", m.Time)
-	fmt.Printf("Label: %s\n", m.Label)
-	fmt.Printf("Counter: %d\n", m.Counter)
-	fmt.Printf("Value: %f\n", m.Value)
 }
 ```
 

sentence.go

@@ -28,6 +28,16 @@ var (
 // ParserFunc callback used to parse specific sentence variants
 type ParserFunc func(BaseSentence) (Sentence, error)
 
+// NotSupportedError is returned when parsed sentence is not supported
+type NotSupportedError struct {
+	Prefix string
+}
+
+// Error returns error message
+func (p *NotSupportedError) Error() string {
+	return fmt.Sprintf("nmea: sentence prefix '%s' not supported", p.Prefix)
+}
+
 // Sentence interface for all NMEA sentence
 type Sentence interface {
 	fmt.Stringer
@@ -225,5 +235,5 @@ func Parse(raw string) (Sentence, error) {
 			return newVDMVDO(s)
 		}
 	}
-	return nil, fmt.Errorf("nmea: sentence prefix '%s' not supported", s.Prefix())
+	return nil, &NotSupportedError{Prefix: s.Prefix()}
 }

sentence_test.go

@@ -1,6 +1,7 @@
 package nmea
 
 import (
+	"errors"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -58,11 +59,11 @@ var sentencetests = []struct {
 		},
 	},
 	{
-		name: "valid NMEA 4.10 TAG Block",
-		raw:  "\\s:Satelite_1,c:1553390539*62\\!AIVDM,1,1,,A,13M@ah0025QdPDTCOl`K6`nV00Sv,0*52",
+		name:     "valid NMEA 4.10 TAG Block",
+		raw:      "\\s:Satelite_1,c:1553390539*62\\!AIVDM,1,1,,A,13M@ah0025QdPDTCOl`K6`nV00Sv,0*52",
 		datatype: "VDM",
 		talkerid: "AI",
-		prefix: "AIVDM",
+		prefix:   "AIVDM",
 		sent: BaseSentence{
 			Talker:   "AI",
 			Type:     "VDM",
@@ -108,17 +109,17 @@ var sentencetests = []struct {
 	{
 		name: "missing TAG Block start delimiter",
 		raw:  "s:Satelite_1,c:1553390539*62\\!AIVDM,1,1,,A,13M@ah0025QdPDTCOl`K6`nV00Sv,0*52",
-		err: "nmea: sentence does not start with a '$' or '!'",
+		err:  "nmea: sentence does not start with a '$' or '!'",
 	},
 	{
 		name: "missing TAG Block end delimiter",
 		raw:  "\\s:Satelite_1,c:1553390539*62!AIVDM,1,1,,A,13M@ah0025QdPDTCOl`K6`nV00Sv,0*52",
-		err: "nmea: sentence does not start with a '$' or '!'",
+		err:  "nmea: sentence does not start with a '$' or '!'",
 	},
 	{
 		name: "invalid TAG Block contents",
 		raw:  "\\\\!AIVDM,1,1,,A,13M@ah0025QdPDTCOl`K6`nV00Sv,0*52",
-		err: "nmea: tagblock does not contain checksum separator",
+		err:  "nmea: tagblock does not contain checksum separator",
 	},
 }
 
@@ -191,32 +192,32 @@ func TestPrefix(t *testing.T) {
 var parsetests = []struct {
 	name string
 	raw  string
-	err  string
+	err  error
 	msg  interface{}
 }{
 	{
 		name: "bad sentence",
 		raw:  "SDFSD,2340dfmswd",
-		err:  "nmea: sentence does not start with a '$' or '!'",
+		err:  errors.New("nmea: sentence does not start with a '$' or '!'"),
 	},
 	{
 		name: "bad sentence type",
 		raw:  "$INVALID,123,123,*7D",
-		err:  "nmea: sentence prefix 'INVALID' not supported",
+		err:  &NotSupportedError{Prefix: "INVALID"},
 	},
 	{
 		name: "bad encapsulated sentence type",
 		raw:  "!INVALID,1,2,*7E",
-		err:  "nmea: sentence prefix 'INVALID' not supported",
+		err:  &NotSupportedError{Prefix: "INVALID"},
 	},
 }
 
 func TestParse(t *testing.T) {
 	for _, tt := range parsetests {
 		t.Run(tt.name, func(t *testing.T) {
 			m, err := Parse(tt.raw)
-			if tt.err != "" {
-				assert.EqualError(t, err, tt.err)
+			if tt.err != nil {
+				assert.Equal(t, err, tt.err)
 			} else {
 				assert.NoError(t, err)
 				assert.Equal(t, tt.msg, m)