There are two types of instance variables used in the C++ code:

1. Variables that reference managed objects and which the GC needs to know
about to properly trace the object graph. We call these "slots".
2. Variables that reference native types (eg int, double, etc) that the GC
*cannot* trace (the GC would misunderstand numbers for memory addresses, for
example).

Previously, we treated these to types quite differently. We used the '// slot'
notation when declaring the first type so that we could automatically generate
code to process the objects. The second type was usually somewhat consistent
but also ad hoc in many places.

Now we mostly use two macros (attr_accessor for the first type, and attr_field
for the second type) that both define the variables and define setters and
getters for them. There are still some places where this needs to be cleaned
up.

One reason that we need to be very careful about the setters for the first
type of variable (the managed object references) is that when the concurrent
GC is running, we need to know when an object reference is stored into an
object that may have already been processed by the marker. If we don't see
this, that object may be considered unreachable by the GC *even though it's
being referenced*. This results in the equivalent to a use-after-free bug in a
language with manually managed memory.

Consistently using the managed object reference accessors means that we can
layer other behavior on the access functions. For example, if we tag objects
with an identifier for the thread that created them, we can log or prevent
mutation access from a different thread.