When a variable does not exist but we wish to acquire the
GlobalVariable object for it, this logic will attempt to create
a new GlobalVariable and add it to the map. Unfortunately it does
this without any locking or atomicity, potentially overwriting a
value written to the same name on a different thread.

When the GlobalVariable returned by this method is cached, as it
is in the JIT logic for global variable reads, it may never see
updates because those writes are going to the winner of the race.
This caused at least one set of specs, for Process.kill, to hang
when the global variable used for indicating a signal had been
damaged in this way.

Instead we computeIfAbsent to ensure only one GlobalVariable will
ever be inserted for this name.

The logic here acquires the Invalidator from the variable and uses
that to guard the cached value. However, if this is a SwitchPoint
invalidator (assumed by the code) then it replaces the SwitchPoint
with a new one after invalidation. If we do not grab the actual
SwitchPoint before the value, we may end up associating the
current value with a newer SwitchPoint and never see the
subsequent update.

This is likely the main cause of intermittent global variable
failures with indy global caching turned on.

The SwitchPoint used to invalidate a given value should always be
acquired prior to retrieving the value. This ensures that value
will always be guarded by its corresponding SwitchPoint, or if the
value changes between the two accesses, the value will be
associated with a prior invalid SwitchPoint and very shortly end
up back in the fallback to get the new value.

With several of these changes, the SwitchPoint was acquired after
the guarded value, meaning we might accidentally associate an old
value with a new SwitchPoint. If that new SwitchPoint is never
invalidated, we will cache the old value forever.

This relates to global variable fixes in prior commits as part of
jruby#8003.

If this variable object has been cached, it must be invalidated
so such code goes back to the table for the new variable.