Never swallow exceptions

It's very bad form to swallow exceptions like this. With the return version, you'd have to handle errors like this:

```python
score = client.score(user_id)
if isinstance(score, requests.exception.RequestException):
    pass  # error handling
elif score.is_ok():
    pass  # ok handling... we can't do this first, because score might not have an is_ok method
else:
    pass  # what exactly is happening here?
```

This is a quickfix, allowing you to handle it like this instead:
```python
try:
    score = client.score(user_id)
    if score.is_ok():
        pass # handle ok
    else:
        pass # still not sure what happens here
except requests.Timeout:
     pass  # hey look! error handling!
```

One could go even further, and instead of having a request.is_ok, throwing some kind of SiftApiError which is a subclass of SiftError. This would simplify error handling even further. In that case it could look like this:
```python
try:
    score = client.score(user_id)
except sift.SiftApiError:
    pass  # handle an api error. The exception has the error code and message as attributes
except sift.SiftError:
    pass  # handle a general error (probably input related)
except sift.Timeout:
    pass  # maybe retry or something. this is actually the requests exception
```

This would be a lot cleaner and more idiomatic.
We can remove this line now right? No need to manually log the stack trace anymore