refactor: create a generic store and stub out dialect queries

[mfridman]

This PR does a few things, although it's primarily mechanical. At a high level, the goal here is 2-fold:

1. Abstract the sql.*-specific logic into a common Store
2. Move the query strings into an internal package that's used by the underlying store implementation. goose itself never sees or deals with raw queries themselves.

TL;DR the goose package only has access to the Store interface, with type-safe methods. A Store is initialized with a specific database dialect, and the internal implementation of Store uses the dialect to implement sql.*-specific logic. It handles things such as scanning and closing *sql.Rows, etc.

This is what goose deals with:

type Store interface {
	CreateVersionTable(ctx context.Context, tx *sql.Tx) error

	InsertVersion(ctx context.Context, tx *sql.Tx, version int64) error
	InsertVersionNoTx(ctx context.Context, db *sql.DB, version int64) error

	DeleteVersion(ctx context.Context, tx *sql.Tx, version int64) error
	DeleteVersionNoTx(ctx context.Context, db *sql.DB, version int64) error

	GetMigration(ctx context.Context, db *sql.DB, version int64) (*GetMigrationResult, error)

	ListMigrations(ctx context.Context, db *sql.DB) ([]*ListMigrationsResult, error)
}

But why?

There are places throughout the goose package we call things like:

db.Exec(GetDialect().insertVersionSQL(), version, direction)

It's too easy to mess up the args, and accidentally omit the required placeholders. In this example, one MUST know that the insertVersionSQL query requires both a version (int) and a direction (bool).

I think it's much safer, and a better separation of concerns, to have a well-defined Store interface with methods like so:

InsertVersion(ctx context.Context, tx *sql.Tx, version int64)

The underlying queries are tucked away in a single place in dialectquery package and goose package never needs to know them, except for when the Store is initialized with a dialect.

The added benefit of the Store is that the caller isn't responsible for dealing directly with sql.* primitives, that's all handled by the Store. E.g., we do this in a bunch of places, whereas now we do it once:

rows, err := GetDialect().dbVersionQuery(db)
defer rows.Close()

for rows.Next() {
	...
	rows.Scan(...)

[mfridman]

To evolve goose I think we need a more sane way to decouple the dialect queries from the package itself.

We mix raw string queries and db *sql.DB queries, which leaves it up to the caller to deal with *sql.Rows directly, that's not great.

[mfridman]

This is the ONLY breaking change in this whole PR. But it's also inconsequential because users can do anything with the SQLDialect since all the methods are private to this package.

[mfridman]

All these queries were moved into the internal/dialect/dialectquery package and exposed as a single interface:

type Querier interface {
	CreateTable() string
	InsertVersion() string
	DeleteVersion() string
	GetMigrationByVersion() string
	ListMigrations() string
}

This makes it really trivial to have a Store interface that calls these queries, which are dialect-specific depending on which querier was initialized:

func (s *store) CreateVersionTable(ctx context.Context, tx *sql.Tx) error {
	q := s.querier.CreateTable()
	_, err := tx.ExecContext(ctx, q)
	return err
}

[mfridman]

This also gets us one step closer to a fully context-aware package without having to instrument too many internal details.