This might be a bit overly pedantic, but the Go spec seems to imply "variable"
only means objects declared with "variable declarations" and "short
variable declarations" as in

    var x int
    y := 7

For example, see the definition of addressable where it's stated:

    """The operand must be addressable, that is, either a variable, pointer indirection, or slice indexing operation; or a field selector of an addressable struct operand; or an array indexing operation of an addressable array."""

Or how the definitions of array type and struct type avoid the word variable:

    """An array is a numbered sequence of elements of a single type, called the element type."""

    """A struct is a sequence of named elements, called fields, each of which has a name and a type."""

It seems reasonable to infer from that wording then that struct fields and array
elements are *not* variables.  However, if that were the case, it would cause problems
with code like this:

    var x [2]int
    p, q := &x[0], &x[1]
    if p == q { ... }

Pointer types are defined as "A pointer type denotes the set of all pointers to
*variables* of a given type", but x[0] and x[1] are not variables, so we wouldn't
be able to take pointers to those array elements.

Also, equality on pointers is defined as "Two pointer values are equal if they
point to the same *variable* or if both have value nil."  In the above code, p and
q point *into* the same variable, but to different elements within that variable.