getaddrinfo: fix CGO_ENABLED=0 and record resolver type (#765)

After https://github.com/ooni/probe-cli/pull/764, the build for
CGO_ENABLED=0 has been broken for miniooni:

https://github.com/ooni/probe-cli/runs/6636995859?check_suite_focus=true

Likewise, it's not possible to run tests with CGO_ENABLED=0.

To make tests work with `CGO_ENABLED=0`, I needed to sacrifice some
unit tests run for the CGO case. It is not fully clear to me what was happening
here, but basically `getaddrinfo_cgo_test.go` was compiled with CGO
being disabled, even though the ``//go:build cgo` flag was specified.

Additionally, @hellais previously raised a valid point in the review
of https://github.com/ooni/probe-cli/pull/698:

> Another issue we should consider is that, if I understand how
> this works correctly, depending on whether or not we have built
> with CGO_ENABLED=0 on or not, we are going to be measuring
> things in a different way (using our cgo inspired getaddrinfo
> implementation or using netgo). This might present issues when
> analyzing or interpreting the data.
>
> Do we perhaps want to add some field to the output data format that
> gives us an indication of which DNS resolution code was used to
> generate the the metric?

This comment is relevant to the current commit because
https://github.com/ooni/probe-cli/pull/698 is the previous
iteration of https://github.com/ooni/probe-cli/pull/764.

So, while fixing the build and test issues, let us also distinguish
between the CGO_ENABLED=1 and CGO_ENABLED=0 cases.

Before this commit, OONI used "system" to indicate the case where
we were using net.DefaultResolver. This behavior dates back to the
Measurement Kit days. While it is true that ooni/probe-engine and
ooni/probe-cli could have been using netgo in the past when we
said "system" as the resolver, it also seems reasonable to continue
to use "system" top indicate getaddrinfo.

So, the choice here is basically to use "netgo" from now on to
indicate the cases in which we were built with CGO_ENABLED=0.

This change will need to be documented into ooni/spec along with
the introduction of the `android_dns_cache_no_data` error.

## Checklist

- [x] I have read the [contribution guidelines](https://github.com/ooni/probe-cli/blob/master/CONTRIBUTING.md)
- [x] reference issue for this pull request: https://github.com/ooni/probe/issues/2029
- [x] if you changed anything related how experiments work and you need to reflect these changes in the ooni/spec repository, please link to the related ooni/spec pull request: https://github.com/ooni/spec/pull/242

internal/netxlite/getaddrinfo_cgo.go

@@ -24,12 +24,37 @@ import (
 	"unsafe"
 )
 
+// getaddrinfoResolverNetwork returns the "network" that is actually
+// been used to implement the getaddrinfo resolver.
+//
+// This is the CGO_ENABLED=1 implementation of this function, which
+// always returns the string "system", because in this scenario
+// we are actually calling the getaddrinfo libc function.
+func getaddrinfoResolverNetwork() string {
+	return "system"
+}
+
+// getaddrinfoLookupANY attempts to perform an ANY lookup using getaddrinfo.
+//
+// This is the CGO_ENABLED=1 implementation of this function.
+//
+// Arguments:
+//
+// - ctx is the context for deadline/timeout/cancellation
+//
+// - domain is the domain to lookup
+//
+// This function returns the list of looked up addresses, the CNAME, and
+// the error that occurred. On error, the list of addresses is empty. The
+// CNAME may be empty on success, if there's no CNAME, but may also be
+// non-empty on failure, if the lookup result included a CNAME answer but
+// did not include any A or AAAA answers.
 func getaddrinfoLookupANY(ctx context.Context, domain string) ([]string, string, error) {
-	return getaddrinfoSingleton.LookupANY(ctx, domain)
+	return getaddrinfoStateSingleton.LookupANY(ctx, domain)
 }
 
 // getaddrinfoSingleton is the getaddrinfo singleton.
-var getaddrinfoSingleton = newGetaddrinfoState(getaddrinfoNumSlots)
+var getaddrinfoStateSingleton = newGetaddrinfoState(getaddrinfoNumSlots)
 
 // getaddrinfoSlot is a slot for calling getaddrinfo. The Go standard lib
 // limits the maximum number of parallel calls to getaddrinfo. They do that
@@ -168,13 +193,13 @@ func (state *getaddrinfoState) addrinfoToString(r *C.struct_addrinfo) (string, e
 	switch r.ai_family {
 	case C.AF_INET:
 		sa := (*syscall.RawSockaddrInet4)(unsafe.Pointer(r.ai_addr))
-		addr := net.IPAddr{IP: state.copyIP(sa.Addr[:])}
+		addr := net.IPAddr{IP: getaddrinfoCopyIP(sa.Addr[:])}
 		return addr.String(), nil
 	case C.AF_INET6:
 		sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(r.ai_addr))
 		addr := net.IPAddr{
-			IP:   state.copyIP(sa.Addr[:]),
-			Zone: state.ifnametoindex(int(sa.Scope_id)),
+			IP:   getaddrinfoCopyIP(sa.Addr[:]),
+			Zone: getaddrinfoIfNametoindex(int(sa.Scope_id)),
 		}
 		return addr.String(), nil
 	default:
@@ -199,13 +224,13 @@ func staticAddrinfoWithInvalidSocketType() *C.struct_addrinfo {
 	return &value
 }
 
-// copyIP copies a net.IP.
+// getaddrinfoCopyIP copies a net.IP.
 //
 // This function is adapted from copyIP
 // https://github.com/golang/go/blob/go1.17.6/src/net/cgo_unix.go#L344
 //
 // SPDX-License-Identifier: BSD-3-Clause.
-func (state *getaddrinfoState) copyIP(x net.IP) net.IP {
+func getaddrinfoCopyIP(x net.IP) net.IP {
 	if len(x) < 16 {
 		return x.To16()
 	}
@@ -214,13 +239,13 @@ func (state *getaddrinfoState) copyIP(x net.IP) net.IP {
 	return y
 }
 
-// ifnametoindex converts an IPv6 scope index into an interface name.
+// getaddrinfoIfNametotindex converts an IPv6 scope index into an interface name.
 //
 // This function is adapted from ipv6ZoneCache.update
 // https://github.com/golang/go/blob/go1.17.6/src/net/interface.go#L194
 //
 // SPDX-License-Identifier: BSD-3-Clause.
-func (state *getaddrinfoState) ifnametoindex(idx int) string {
+func getaddrinfoIfNametoindex(idx int) string {
 	iface, err := net.InterfaceByIndex(idx) // internally uses caching
 	if err != nil {
 		return ""