fix segfault in GlobalPropertyGetter() (closes #89)

GlobalPropertyGetter() is a static function. It can be invoked on
a context which has already been disposed off.

It turned out that there were two possible segfault reasons.

The most obviuos one was NULL pointer dereferencing.

However, there is no way to check whether the context is alive by
examining content of it or its sandbox. Both could look valid, but cause
segfaults in node. As a woraround, we add a self-reference which we clear
on destruction. A valid self-reference is a solid indication of a
valid context now.
But `ObjectWrap` is part of Node and not included in v8.

```c++
  inline void Wrap(v8::Handle<v8::Object> handle) {
    assert(persistent().IsEmpty());
    assert(handle->InternalFieldCount() > 0);
    handle->SetAlignedPointerInInternalField(0, this);
    persistent().Reset(v8::Isolate::GetCurrent(), handle);
    MakeWeak();
  }
```
```c++
  template <class T>
  static inline T* Unwrap(v8::Handle<v8::Object> handle) {
    assert(!handle.IsEmpty());
    assert(handle->InternalFieldCount() > 0);
    // Cast to ObjectWrap before casting to T.  A direct cast from void
    // to T won't work right when T has more than one base class.
    void* ptr = handle->GetAlignedPointerFromInternalField(0);
    ObjectWrap* wrap = static_cast<ObjectWrap*>(ptr);
    return static_cast<T*>(wrap);
  }
```

`ObjectWrap` only contains some utility methods, a `Persistent` handle that holds the wrapped obect with an internal field pointer to the object instance. This pointer is what is returned by `ObjectWrap::Unwrap`, not a `Local` handle. That is gotten by the `handle` accessor. Upon wrapping, the persistent handle is made weak with the following callback, which will be called when all remaining references to the object are weak:
```c++
  static void WeakCallback(
      const v8::WeakCallbackData<v8::Object, ObjectWrap>& data) {
    v8::Isolate* isolate = data.GetIsolate();
    v8::HandleScope scope(isolate);
    ObjectWrap* wrap = data.GetParameter();
    assert(wrap->refs_ == 0);
    assert(wrap->handle_.IsNearDeath());
    assert(
        data.GetValue() == v8::Local<v8::Object>::New(isolate, wrap->handle_));
    wrap->handle_.Reset();
    delete wrap;
  }
```
Calling `ObjectWrap::Ref` makes the persistent handle nonweak and increases the refcount. `ObjectWrap::Unref` decreases the refcount and makes the persistent handle weak again if the refcount goes to 0. Thus, the weak callback won't get invoked while there is a reference to the wrapped object, because the garbage collector will not touch persistent handles.

https://github.com/joyent/node/blob/master/src/node_object_wrap.h