Improve SkyCoord equality operator - #20266

Compare the two info._represent_as_dict() dicts item by item instead of routing
through frame equality

1. Why the primary/extra split existed

A SkyCoord can carry any attribute registered in frame_transform_graph, not just
those of its own frame, so that a round trip through another frame preserves them.
SkyCoord.__setattr__ files anything that is not an attribute of self.frame into
self._extra_frameattr_names and stores it as self._<name>.

The two kinds then diverge in one way that matters here. A frame broadcasts its own
attributes against the data at construction (BaseCoordinateFrame.__init__ folds their
shapes into self._shape, and Attribute.__get__ broadcasts on access), whereas
SkyCoord.__getattr__ returns the raw stored value. So a frame attribute always has the
frame's shape, and an extra frame attribute can have any shape at all — including one
larger than the coordinate it is attached to.

_represent_as_dict() erases the distinction: it does
attrs.extend(frame_transform_graph.frame_attributes.keys()) and then
getattr(self._parent, key, None) for each, which for a SkyCoord picks up both kinds
identically. Values keep their natural shapes, so the broadcasting difference above is
handled by numpy rather than by explicit shape code.

2. Why False and not an exception

_represent_as_dict() skips items whose value is None, so an unset attribute is
simply an absent key, and the frame name, representation_type and differential_type
are present as plain strings. Every one of the five conditions in the documented
definition of equality is therefore either a differing key or a differing value:

None of these has any reason to raise — they are all just "not equal". A differing key
short-circuits to all-False, since there is nothing to compare element-wise.

3. Implementation

SkyCoord.__eq__ is now, in full:

• Frame on the right-hand side: return self == SkyCoord(value, copy=False), so the
  frame goes through the same comparison. The value._data is None guard stays ahead of
  it, otherwise the message would come from the SkyCoord constructor instead.
• Not a SkyCoord: return NotImplemented, unchanged.
• repr1.keys() != repr2.keys(): return np.zeros(shape, bool)[()] where shape is
  np.broadcast_shapes(self.shape, value.shape). The [()] is what makes a scalar
  comparison return np.False_ rather than a 0-d array.
• Otherwise out = out & _item_equal(val1, repr2[attr]) over the items, starting from
  True. The output shape falls out of the broadcasting rather than being computed;
  it has to, because an extra frame attribute can make the result larger than either
  input (see the test below).

_item_equal() is a module-level helper for one case: an attribute whose value is
itself a frame, such as SkyOffsetFrame.origin. Comparing two frames raises rather than
returning False when they are not equivalent, or when only one of them has data, so
for an attribute that has to be translated into "not equal". The catch is narrowed two
ways — the value must be a BaseCoordinateFrame, and the message must start with
cannot compare, which is the prefix used by all five raise sites in
baseframe.py and representation/base.py. Anything else propagates.

BaseCoordinateFrame._frameattr_equiv is left in place; it is still used by
is_equivalent_frame() and by SkyCoord.__setitem__.

Shape-mismatch messages now name the offending item and carry numpy's detail, and all
of them use the cannot compare: prefix already used elsewhere in the subpackage:

cannot compare: extra frame attribute 'obstime' has shape mismatch: operands could not
be broadcast together with shapes (2,) (3,)

4. Testing

New and rewritten tests in astropy/coordinates/tests/test_sky_coord.py:

test_equal_exceptions is removed — the exceptions it asserted no longer exist. In
test_frames.py, test_frame_coord_comparison had two pytest.raises(TypeError) blocks
for comparisons involving a SkyCoord; both now assert np.False_, and the reflected
direction was added.

Attribute types exercised by the above: TimeAttribute, QuantityAttribute,
EarthLocationAttribute, CartesianRepresentationAttribute, DifferentialAttribute
and CoordinateAttribute, plus masked data.

$ python -m pytest astropy/coordinates
2051 passed, 48 skipped, 10 xfailed in 7.44s

$ python -m pytest astropy/coordinates/tests/test_sky_coord.py -k equal
12 passed, 426 deselected in 0.13s

$ python -m pytest docs/coordinates
24 passed in 1.50s

$ python -m pytest astropy docs
32303 passed, 439 skipped, 265 xfailed in 177.70s

The full-suite figure is from an earlier run of this branch, before the shape-mismatch
message change in the final commit; the coordinates and docs figures above are current.

5. Backwards compatibility

SkyCoord.__eq__ and SkyCoord.__ne__ are the only changed API. Comparisons that
succeeded before return the same values; what changes is that comparisons which raised
now return False or an array containing False. Code that relies on catching the
exception will stop working, hence the changelog fragment at
docs/changes/coordinates/20266.api.rst.

Two behaviour changes worth calling out beyond "stops raising":

• Comparing a SkyCoord to a BaseCoordinateFrame previously ignored the extra frame
  attributes entirely, because it delegated to self.frame == value. It no longer does,
  so a SkyCoord carrying an obstime is not equal to a bare ICRS frame. The old
  behaviour made equality non-transitive: sc(obstime=A) == fr and sc(obstime=B) == fr
  were both True while sc(obstime=A) != sc(obstime=B).
• Comparing coordinates in different frame classes returns False instead of raising
  TypeError.

BaseCoordinateFrame is unmodified, so frame-to-frame equality, is_equivalent_frame(),
__setitem__, concatenate() and the transformation machinery are bit-for-bit
unchanged.

The docs/coordinates/skycoord.rst "Exact Equality" section still describes the old
raising behaviour and needs updating; that is not in this PR yet.