v0.5.0 included #207, which replaced reflect mode with package mode. One
issue with package mode that came up (ref: #216) was that generated
mocks for interfaces that referred to alias types were referring to the
aliases' underlying names instead.

e.g.,
some package:
```go
package somgpkg

import "somepkg/internal/apicodec"
...
type Codec = apicodec.Codec
```

mockgen input:
```go
type Foo interface{
	Bar() somepkg.Codec
}
```
mock:
```go
func (m *MockFoo) Bar() apicodec.Codec { // This is a problem, since apicodec is an internal package.
    // ...
}
```

While technically this problem is solved in Go 1.23 with explicit alias
types representation, (indeed, if you run mockgen on the example in the
linked issue with `GODEBUG=gotypesalias=1`, you get the expected
behavior) since we support the last two versions, we can't bump `go.mod`
to 1.23 yet. This leaves us with the old behavior, where `go/types` does
not track alias types. You can tell if an object is an alias, but not a
type itself, and there is no way to retrieve the object of interest at
the point where we are recursively parsing method types.

This PR works around this issue (temporarily) by using syntax
information to find all references to aliases in the source package.
When we find one, we record it in a mapping of underlying type -> alias
name. Later, while we parse the type tree, we replace any underlying
types in the mapping with their alias names.

The unexpected side effect of this is that _all_ references to the
underlying type in the generated mocks will be replaced with the alias,
even if the source used the underlying name. This is fine because:
* If the alias is in the mapping, it was used at least once, which means
its accessible.
* From a type-checking perspective, aliases and their underlying types
are equivalent.

The nice exception to the side effect is when we explicitly request mock
generation for an alias type, since at that point we are dealing with
the object, not the type.

With this PR, the mocks get generated correctly now:
```go
func (m *MockFoo) Bar() Codec {
    // ...
}
```

Once we can bump `go.mod` to 1.23, we should definitely remove this,
since the new type alias type nodes solve this problem automatically.

This PR fixes an issue where if the name of an argument to a method that is being mocked collides with the name of a package that needs to be imported, mockgen could generate uncompilable code.

Resolves #218

In source mode, when generating a mock within the same package that uses
names from a package that is imported with an alias, the generated mock
should obey -imports properly and generate imports with the provided
alias.

If the generated code is not using the same aliases as the main filed in
a package the go compiler will still happily run but if you want ot use
this package as a source in another package where you want to generate a
mock, mock will fail because it will not know what to do with a package
that is imported with two different names in a source package.

This patch fixes the generation by making `-imports` handling do a more
correct thing.

It can be argued that the correct behavior is, by default use the the
same package aliases as the ones in the source file, however that change
looked way more invasive and i didn't see a good coverage of tests that
would help me make sure the changes worked well.

This is what i found to be the least invasive fix for #166.

This PR copies the gomock definition and tests from rules_go with
minimal changes:

* Replacing github.com/golang/mock with go.uber.org/mock
* Replacing `load` statements accordingly
* Setting up a Bazel and a Go module in the "bazel" directory

Note that the Go module uses v0.4.0 of go.uber.org/mock, because the
latest version is no longer compatible with the gomock rule
(bazel-contrib/rules_go#4153). We will update
the rule and mockgen version in subsequent PRs.

This is a first step in addressing #225

Prepare the changelog for a v0.5.1 release which contains several bug
fixes.

Return the changelog to development status.

Alias replacements derived from syntax were introduced in #220 as a way
to ensure the aliases used in source code were also used. This helped
ensure packages mode worked on go1.22, which didn't have explicit alias
node support in the `go/types` package.

Alias replacements have a couple issues:
* They flat out replace any would-be references to an underlying type
with an alias type.
* They don't properly handle aliases to generic type instantiations
(ref: #243)

Now that go1.24 is released, we can bump `go.mod` to go1.23, which means
we can ensure `go/types` has an explicit `types.Alias` node for type
aliases, and we can remove the alias replacement logic.

Prepare the changelog for a v0.5.2 release containing a bug fix caused
by outdated go version and alias replacements logic.

Return to development changelog status.

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

- **Documentation**
- Added an "Unreleased" section to the changelog for tracking future
updates.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

This adds support for a 3rd option for creating mocks after reflect and
source-mode: the archive mode. Archive mode lets you load archive files
to create mocks. This can come in handy for writing Bazel rules that
produce intermediary archive files and automatically codegen mocks in
Bazel environments.

Rebased version of #125

---------

Co-authored-by: Zhongpeng Lin <zplin@uber.com>
Co-authored-by: Sung Yoon Whang <sungyoonwhang@gmail.com>
Co-authored-by: Sung Yoon Whang <sungyoon@uber.com>

Removes the broken reflect mode in the bazel aspect, in favor of archive
mode which was landed in #258

---------

Co-authored-by: Zhongpeng Lin <zplin@uber.com>

Hi! In #259 was introduced archive mode for bazel rule, but no support
for mock_names.
This PR added `mock_names` attr to `_gomock_archive` rule.

Fixes #274.

---------

Co-authored-by: Jacob Oaks <joaks@uber.com>

go1.25 was released, let's test it in CI.

This includes fixes for go1.25 and the new archive mode.