Following a chain of sectors to merge them in a new stream
At least both FAT filesystem and Microsoft's CFB files follow the same pattern: to specify file contents, one provides an index of starting sector *s0*. A parser must follow the chain of sectors, as specified in a FAT-like table, i.e.:

* 1st sector = *a0*
* 2nd sector = *fat[a0]*
* 3rd sector = *fat[fat[a0]]*
* etc

until it meets certain terminator (like -1 or -2) in the FAT table. After that, if we would want to do further parsing on the file contents, we should reassemble all these individual sectors into one new stream (and probably trim it to the size specified in a separate field somewhere in the directory entry).

The following structure can model most of this behavior, but not all:

```yaml
seq:
  # Offset to the FAT table, which is, for simplicity sake, consists of 4-byte entries
  - id: ofs_fat
    type: u4
  # A pointer to the first sector
  - id: file_first_sector
    type: sector_ptr
  # Full size that we need to trim file size to
  - id: file_full_size
    type: u4
types:
  fat:
    seq:
      - id: entries
        type: u4
        repeat: eos
  sector_ptr:
    seq:
      - id: current_ptr
        type: u4
    instances:
      body:
        pos: current_ptr * 512
        size: 512
        if: current_ptr != -1
      next:
        pos: _root.ofs_fat + 4 * current_ptr
        type: sector_ptr
        if: current_ptr != -1
```

This effectively allows to access file sectors one by one by using:

```ruby
parsed.file_first_sector.body # 1st sector contents
parsed.file_first_sector.next.body # 2nd sector contents
parsed.file_first_sector.next.next.body # 3nd sector contents, etc
```

However, there is no simple way to unite all these sectors and trim it to `file_full_size`, except in the app code, to continue parsing, i.e:

```ruby
data = ''
s = parsed.file_first_sector
while not s.body.nil? do
  data << s.body
  s = s.next
end
```

Any ideas on what would be the best syntax to do it?