Update various comments and variable names to make golint happy.

Previously there were around a few dozen items it complained about; this eliminates all of those issues.

$ GOPATH/bin/golint . | wc -l
       0
$ go test
PASS
ok      apns    0.013s
Add a legacy file and tests to avoid annoying breaking changes.

Lately a legitimate number of package managers for Go have cropped up, but this lib came into existence when the options were a little more sparse (i.e. "breaking public API change? Fork the repo!")

This supports #11 and keeps the identifiers around but outside of the normal code...for now. I'll probably wind up forking eventually, but we'll see if we can be creative in the meantime.

$ $GOPATH/bin/golint .
legacy.go:10:2: don't use ALL_CAPS in Go names; use CamelCase
legacy.go:11:2: don't use ALL_CAPS in Go names; use CamelCase
legacy.go:12:2: don't use ALL_CAPS in Go names; use CamelCase
legacy.go:13:2: don't use ALL_CAPS in Go names; use CamelCase
legacy.go:14:2: don't use ALL_CAPS in Go names; use CamelCase
legacy.go:15:2: don't use ALL_CAPS in Go names; use CamelCase

$ go test
PASS
ok      apns    0.013s
Update the de-linted code to include the fix from #12
Merge pull request #13 from anachronistic/legacy-interface

Legacy interface
Initial main structure of a persistent connection; completely non-functional as of now.

What's changed:
- PushNotification.Identifier is now an uint32; it means we can use the whole identifier range. This also means that IDENTIFIER_UBOUND is no longer needed.
- A new Response type is defined which maps directly to the apple response

What's added:
- There's now a Connection, which is backed by a simple system of goroutines connected by queues. The way it will work is this:
A sender goroutine runs through the push notification queue, (connects to APNS if the conection is down) and passes the notifications on to the sent queue.
A reader goroutine blocks waiting for a response from APNS and passes it on and closes the connection.
A 'limbo' goroutine keeps a queue of sent notifications, and discards / requeues notifications when it receives responses.
It also sends "success" responses to itself every now and then, to flush out the notifications which have been around longer than TimeoutSeconds.

Things I still need to implement:
- Actually connecting to APNS
- Actually sending notifications
- The sender should probably exponentially backoff if it can't reconnect (up to some limit)
- Documentation
- Tests
- Probably lots more things

Things I still need to think about:
- The reader goroutine might need to be spawned each time the connection is started rather than running on (because what happens when the connection is down?
  (it can't connect itself, that's the sender's responsibility)
- Now that the sender routine is responsible for reconnecting itself each time it disconnects, the user doesn't have direct access to the state of the connection.
  That is to say, if for some reason the sender is unable to reconnect for an extended period of time (say, in a network outage)
  the notifications will just pile up and you won't notice right away that they're not being sent.
  On the one hand we could say "this is really bad" and add another error queue for connection errors; but how can the user reasonably deal with them anyway?
  Since avoidable errors (bad configuration, etc) would probably be caught in Start() we can probably just log'em and hope?
- Graceful shutdown feels complicated because of the channels going in a loop. If a goroutine doesn't know its input stream is finished, it can't close its downstream channels...
TimeoutSeconds was redundant
remove IdentifierUbound