Thin proxy class for hashables
You asked, "Can you think of any disadvantages of this approach?" One obvious problem is that this requires you to construct a new class each time the wrapper is called, which potentially ends up wasting a lot of memory. So you would want to cache and reuse these classes.

class Wrapper(object):
    # A map from (value type, wrapper class) to wrapped class
    __cache = {}

    def __new__(cls, value):
        value_type = type(value)
        bases = value_type, cls
        try:
            wrapper_class = cls.__cache[bases]
        except KeyError:
            wrapper_class = type(value_type.__name__, bases, {})
            cls.__cache[bases] = wrapper_class
        return wrapper_class(value)


Note that this is a rare case where we actually want to use a private name — the idea is to avoid a name clash when wrapping a class that already has a cache (or _cache, or whatever name we pick) attribute.

I can't help feeling, though, that Martijn Pieters is right in the Stack Overflow version of this question: if you just want to proxy a dictionary key, then you just need to proxy the __eq__ and __hash__ special methods. Keep it simple!