Copy-once slices

A copy-once slice can be used to wrap an existing buffer, when you can
guarantee that the buffer will outlive the slice.  This means that we
don't need to make an initial copy of the buffer; we can just use the
existing buffer directly.  The first time we copy the slice, though, we
duplicate the original wrapped buffer into a new managed buffer
instance.  (We have to do this because we can't make any guarantees
about how long the copied slice will live.)  We also go ahead and update
the initial slice (which originally wrapped the existing buffer
directly) to point into the new managed buffer.  This ensures that if we
copy the original slice twice, we won't create yet another duplicate of
the underlying buffer.
Lightly copied slices

You can now make a “light” copy of a slice.  This is similar to the
existing “full” copy operation, in that the new slice points into the
same buffer as the original.  However, by making a light copy, you
assert that you'll ensure that the newly copied slice will not outlive
the original slice.  Some slice implementations can use that guarantee
to make a copy with less overhead.  For instance, the new copy-once
slice already knows that the underlying buffer will outlive the original
slice, and will therefore also outlive any light copies.  That lets us
reuse the existing buffer for light copies.  (For full copies, we can't
assume any guarantees about how the life of the underlying buffer
relates to the lives of the new full copies, and so we still have to
make duplicate the actual slice content.)
Merge branch 'feature/copy-once-slice' into develop

* feature/copy-once-slice:
  Lightly copied slices
  Copy-once slices