There is no way I can make a safe implementation of the parser by slurping
thing into memory, indexes people use are just too big.

So I made a new API which force consumers to manage that.
They can choose to use a bytes.Reader, *os.File, mmaped thing, ...

…tation docs

Update index generation tests to assert indices are identical.

Fix minor typo in the test utility name and a bug where the check was
not using both index instances to assert they are identical.
Also refactor the use of lock in favour of wait group for better
readability of the assertion logic.

Previous changes added the `ForEach` interface to `Index` type which
enables iteration through the index by multihash and offset. However,
not all index types contain enough information to construct the full
multihash. Namely, `CarIndexSorted` only stores the digest portion of
the multihashes.

In order to implement `ForEach` for this index type correctly uses the
`uint64` max value as the code in the multihash and document the
behaviour where the iterations over this index type should not rely on
the returned code. Note that the max value is used as a code that
doesn't match any existing multicodec.Code to avoid misleading users.

This index type does not store enough information to satisfy `ForEach`.
It only contains the digest of mulithashes and not their code. Instead
of some partial functionality simply return an error when
`ForEach` is called on this function type. Because, there is no valid
use for this index type and the user should ber regenerating the index
to the newer `car-multihash-index-sorted` anyway.

Update tests to include samples of both types and assert IO operations
and index generation for both formats.

…and return stats

`go-cid` exposes `Sum` API that facilitates calculation of the CID from
`[]byte` payload. `go-multihash` now exposes `SumStream` which can
calculate digest from `io.Reader` as well as `[]byte`. But,
unfortunately the equivalent API does not exist in `go-cid`.

To avoid copying the entire block into memory, implement CID calculation
using the streaming multihash sum during inspection of CAR payload.

This reverts the earlier changes to get the message consistent. Note,
the CID we expect is the one in the CAR payload, not the calculated CID
for the block.

Benchmark the `Reader.Inspect` with and without hash validation using a
randomly generated CARv2 file of size 10 MiB.

Results from running the benchmark in parallel locally on MacOS
`Intel(R) Core(TM) i7-1068NG7 CPU @ 2.30GHz` repeated 10 times:

```
Reader_InspectWithBlockValidation-8       5.30ms ±48%
Reader_InspectWithoutBlockValidation-8     231µs ±42%

name                                    speed
Reader_InspectWithBlockValidation-8     2.08GB/s ±35%
Reader_InspectWithoutBlockValidation-8  46.8GB/s ±32%

name                                    alloc/op
Reader_InspectWithBlockValidation-8       10.7MB ± 0%
Reader_InspectWithoutBlockValidation-8    60.7kB ± 0%

name                                    allocs/op
Reader_InspectWithBlockValidation-8        4.54k ± 0%
Reader_InspectWithoutBlockValidation-8     2.29k ± 0%
```

Cosmetic refactor to rename `car.CarStats` to `car.Stats`, which looks
more fluent when using the API.

Return potential error when reading section error as varint. Add test to
verify the error is indeed returned.

Use `errors.New` instead of `fmt.Errorf` when no formatting is needed in
error message.

Revert the changes to `index.Index` interface such that it is the same
as the current go-car main branch head.

Reverting the changes, however, means that unmarshalling untrusted
indices is indeed dangerous and should not be done on untrusted files.

Note, the `carv2.Reader` APIs are changed to return errors as well as
readers when getting `DataReader` and `IndexReader`. This is to
accommodate issues detected by fuzz testing while removing boiler plate
code in internal IO reader conversion. This is a breaking change to the
current API but should be straight forward to roll out.

Remove index fuzz tests and change inspection to only read the index
codec instead of reading the entire index.

Revert changes to serialization of `insertionindex` postponed until the
streaming index work stream.