Add no_std, and switch to a better iobuf representation.

Tradeoff: No more zero-copy conversion from a vector.

However, now empty() is free, and there's only one allocation per
backing buffer instead of 2 (one for data, one for refcount). There's
also less overhead. The old representation was:

struct Iobuf {
  data:   *mut RefcountedBuf,
  lo_min: uint,
  lo:     uint,
  hi:     uint,
  hi_max: uint,
}

struct RefcountedBuf {
  data:         *mut ByteVec,
  strong_count: uint,
  weak_count:   uint,
}

struct ByteVec {
  data: *mut u8,
  len:  uint,
  cap:  uint,
}

So to get at any data, you needed to chase 4 pointers: 1 to the Iobuf,
1 to the RefcountedBuf, and 1 to the ByteVec, then 1 to the data itself.
There's also 3 useless fields: len, cap, and weak_count. len and cap
are redundant with the Iobuf, and weak_count is just never used.

This is the new representation:

struct NewIobuf {
  data:     *mut NewRefcountedBuf,
  is_owned: bool,
  lo_min:   uint63,
  lo:       uint,
  hi:       uint,
  hi_max:   uint,
}

If is_owned is false, `data` points directly to the data. If it's true,
it points to a `NewRefcountedBuf`:

struct NewRefcountedBuf {
  cap:       uint,
  ref_count: uint,
  data:      [u8], // directly embedded, the data pointer actually points
                   // here, and `cap` and `ref_count` are at negative
                   // offsets.
}

This representation reduces indirections to the data, and the only
tradeoffs are _slightly_ slower access to lo_min and inability to
do zero-copy ownership-taking of `Vec`s: they must be copied now.