Add a prototype for setting up callbacks on a method from a class object

Here you go, this works for adding callbacks at the class- and instance- level.  e.g.

```python
class Car(object):
    def __init__(self, name, speed):
        self.name = name
        self.speed = speed

    @supports_callbacks
    def get_speed(self):
        print "getting speed"
        return self.speed

# @pre_callback(Car.speed, takes_target_args=True)
def mycallback1(self):
    print "how's my driving?"

# @post_callback(Car.speed, takes_target_results=True)
def mycallback2(speed):
    if speed < 55:
        print "that's pretty slow"
    else:
        print "nice and fast"

# add to all cars:
Car.get_speed.add_post_callback(mycallback2, takes_target_result=True)

ferrari = Car('ferrari', 180)
truck = Car('truck', 50)

# add to just truck:
truck.get_speed.add_pre_callback(mycallback1, takes_target_args=True)

print "calling ferrari:"
ferrari.get_speed()
print

print "calling truck:"
truck.get_speed()
```

prints:
```
calling ferrari:
getting speed
nice and fast

calling truck:
how's my driving?
getting speed
that's pretty slow
```

It's not perfect, but perhaps that will get you unstuck.  If you get the tests running I'll add some to test this case.

If you try to maintain one registry-per-instance you will have to ensure that callbacks added via the class's registry get pushed to all its instances, and the same goes for callbacks that get removed.  that's certainly doable, but by passing in a parent registry, you get those updates on all the children for free since the data is referenced.  
i'd rather deal with getting the sort order right in this one spot, then try to keep all the instance callbacks in sync with the parent.