Test that we won't keep retrying URL indefinitely

Add a test to verify that we don't keep trying to crawl an item that
repeatedly returns HTTP 500 errors; in this case we allow 4 retries.

Because nothing should be sent over the `crawled` channel  (since the
`*CrawlMessageItem` being processed will be rejected by `CrawlURL()`),
we use the value stored in the Redis-backed `*TTLHashSet` to determine
if the maximum number of retires has been reached.
Use HTTP status codes from net.http where possible

Use the HTTP status codes from Go's `net.http` package[1] to make the
code more readable.

Once noticeable exception is a HTTP 429 code, which is currently not
exported publicly from that package.

[1]: http://golang.org/src/pkg/net/http/status.go
Convert magic values to constants

Make it clear what `-1` and `0` represent by replacing these values with
constants.

Export these constants publicly so that we can re-use them in our tests
(I'd like to find a better way to do that).
Reinstate `ttlHashSet.Exists()`

It makes the tests more readable and it's useful in the context of this
generic and reusable package.
Rename `val` to `crawlCount`

To make it more obvious what this variable stores.
Defer mutex unlock until function returns

`defer` on `t.mutex.Unlock()` so that the mutex is unlocked whenever
the `*TTLHashSet.Incr()` function returns.

This ensures that the mutex is always unlocked when this function
returns. Previously an error may have caused the function to return but
left the mutex locked, causing other goroutines to block.