Support "clamping" of stream start in KaitaiStream
Currently it's challenging to parse non-trivial structures from a stream if the position is not at the beginning.   As an example:

Sample ksy
```
meta:
  id: Foo
  endian: le
seq:
  - id: offset
    type: u4
  - id: size
    type: u4
instances:
  body:
    pos: offset
    size: size
```

Sample Python Code demonstrating issue
```
foo_data = b'\x08\x00\x00\x00\x04\x00\x00\x00\xAA\xBB\xCC\xDD'
foo1 = Foo.from_io(io.BytesIO(foo_data))
foo.body
# Expected body
b'\xaa\xbb\xcc\xdd'

# Create a stream with 20 bytes of arbitrary data we'll skip over
stream_data = bytes(range(0x41, 0x41+20)) + foo_data
ios = io.BytesIO(stream_data)
ios.seek(20)
foo2 = Foo.from_io(ios)
foo2.body
# Actual
b'IJKL'
# Expected
# b'\xaa\xbb\xcc\xdd'
```

To support this I'd request that the ability to optionally "clamp" the stream in the constructor for KaitaiStream so that the original position is saved, and a few operations like seek() and size() can be modified.  Additionally it'd by handy to have KaitaiStruct.from_io() also support this parameter.

my kludge (for python) is currently:
```
class ClampedKaitaiStream(KaitaiStream):
    def __init__(self, stream, clamp=False):
        super().__init__(stream)
        if clamp:
            self._orig_pos = stream.tell()
        else:
            self._orig_pos = None

    def seek(self, n):
        if self._orig_pos != None:
            n += self._orig_pos
        super().seek(n)

    def size(self):
        full_size = super().size()
        if self._orig_pos != None:
            full_size -= self._orig_pos
        return full_size

    def pos(self):
        p = self._io.tell()
        if self._orig_pos != None:
          p -= self._orig_pos
        return p
```