Optimize decoding

[Stebalien]

This optimizes:

1. readByte: It turns out that frequently casting an interface to an interface is really slow, but casting an interface to a concrete type is fast.
2. Deferred: This avoids most of the unnecessary allocations and copies in Deferred.UnmarshalCBOR, and switches to an iterative (rather than recursive) implementation.
3. ScanForLinks: As with Deferred, this is now non-recursive.

Note: depth limits have been removed from Deferred as the implementation is no longer recursive. ScanForLinks never appeared to have depth limits.

[Stebalien]

Based on #33.

[whyrusleeping]

Looks pretty tasty.

[Stebalien]

Benchmarks:

name            old time/op    new time/op    delta
Marshaling-4       878ns ± 2%     874ns ± 2%     ~     (p=0.579 n=5+5)
Unmarshaling-4    4.96µs ± 3%    4.40µs ± 2%  -11.26%  (p=0.008 n=5+5)
LinkScan-4        4.74µs ± 1%    4.51µs ± 1%   -4.94%  (p=0.008 n=5+5)
Deferred-4        12.2µs ± 0%     3.5µs ± 1%  -71.09%  (p=0.016 n=4+5)

name            old alloc/op   new alloc/op   delta
Marshaling-4        160B ± 0%      160B ± 0%     ~     (all equal)
Unmarshaling-4    3.48kB ± 0%    3.46kB ± 0%   -0.69%  (p=0.008 n=5+5)
LinkScan-4          880B ± 0%      880B ± 0%     ~     (all equal)
Deferred-4        17.3kB ± 0%     0.1kB ± 0%  -99.45%  (p=0.008 n=5+5)

name            old allocs/op  new allocs/op  delta
Marshaling-4        10.0 ± 0%      10.0 ± 0%     ~     (all equal)
Unmarshaling-4      47.0 ± 0%      43.0 ± 0%   -8.51%  (p=0.008 n=5+5)
LinkScan-4          25.0 ± 0%      25.0 ± 0%     ~     (all equal)
Deferred-4           222 ± 0%         3 ± 0%  -98.65%  (p=0.008 n=5+5)