Use a plain delegate instead and resolve by default

* `IExcelRow.RowId` and `IExcelRow.SubrowId` exist to implement `ICollection<T>.Contains`.
  * `System.Collections.Generic.EnumerableHelpers.ToArray` and alike in LINQ has an optimization for `ICollection<T>`. As it requires `Contains` to be implemented, exposing `RowId` and `SubrowId` in a generic way will make it possible to implement that in O(1).
* `ExcelSheet` constructor now preallocates lookup lookup tables.
  * `.exh` file comes with information on how many rows are there, so we know the exact number of items that needs to be allocated.
  * Using an array directly bypassing list wrappers may provide an additional speed boost.
  * In case `.exh` file contains a wrong information on number of rows, which is an unlikely case, `Array.Resize` is used to reallocate the array.
* `ExcelSheet.UnsafeCreateRow/Subrow/At` has been added.
  * These functions assume that boundary checks are done by callers.
  * As enumerators always work inside the boundary, especially when the collection is immutable, `IEnumerator{T}.Current` can skip boundary checks.
* `DefaultExcelSheet<T>` and `SubrowsExcelSheet<T>` has been added.
  * As sheets are usually not meaningful without knowing what is in it in the first place, it would be better to specialize for each variants.
  * This effectively hides subrow operations from sheets of default variants.
  * This removes `HasSubrows` check from getter functions.
* Added `SubrowsExcelSheet.Try/GetRow/OrDefault` variants that returns `SubrowCollection<T>` instead.
  * This makes it convenient to iterate over subrows under one row ID.
  * This makes it faster to access multiple subrows under one row ID, as lookup operation is done on obtaining the collection. Once the collection is constructed, accessing subrows is an O(1) operation.
* `ExcelModule.GetSheet` uses static lambda in place of `SheetCache.GetOrAdd`.
  * This will avoid heap allocation if a corresponding sheet is already loaded.
* Named value tuples in `ExcelSheet` are replaced with `record struct`.
  * This reduces the size of each lookup element from 16 bytes to 12 bytes.

Most of sheets do not have large gaps across items. That fact can be
used to make a lookup array instead of lookup dictionary, which will
even further reduce the time spent translating row ID to row index.

Suggestions on Excel

* `MethodInfo.Invoke` throws `TargetInvocationException` if the method
  throws an exception; changed to handle that.
* Added comments for some functions.

Making `IEnumerator<T>.Current` evaluate on demand can let an invalid
value get passed to UnsafeCreate functions. Creating them on `MoveNext`
will guarantee that UnsafeCreate functions are called only from the
context where the preconditions are met.

Reformat code, documentation/enumerator correctness fixes

Reformat code

types

Use constructors directly on Subrow/ExcelSheet, specialize exception