See: #107

Added an Abstract Base Class for LGDOContainers, which are ArrayLike objects and can be placed inside of tables. LGDOContainers are expected to implement methods for manipulating the capacity and size of the containers. Capacity controls the number of rows in memory, while size controls the length of the container; capacity may be larger than size, resulting in "padding" at the end. The advantage of this approach is that it enables changes in size without reallocating memory (always for shrinking, most of the time for growing). The cost is the extra memory used by this padding (although resizes require allocating a new array and then copying data over, requiring a spike in memory usage, so this cost is not so big). Methods and options have been added for "trimming" the capacity to match the size of the array in case the user prefers to not have this padding for some reason.

As a result of this change, the returned values for core.read and store.read have (sometimes) changed. Before, when reading an LGDO object in place, they would return the number of rows read. Now, they resize the array to obj_buf_start + n_rows_read. The reason for the old behavior was that we did not want to shrink arrays when not enough rows were in the file to fill a Table in place, since the reallocation could cause problems. Since shrinking no longer requires reallocation, this is no longer problematic. A major benefit is that the read functions are both simpler to use since they have consistent returns. It should be noted that this change will break code in other LEGEND packages.

When resizing, if the capacity is smaller than the new size, the behavior is to reserve more capacity up to the next power of 2 larger than the new size. When reading a huge number of files, this will reduce the time spent reallocating/copying arrays from O(n) to O(log(n)); it is not clear to me how important this is, but someone can try running tests of reading a large number of files to check.
Detailed changes:

• Array, VectorOfVectors, Table, ArrayOfEqualSizeArrays, and the encoded Array classes all implement the new LGDOContainer base class. In particular they have reserve_capacity, get_capacity, and trim_capacity defined. In some cases, this involved implementing other methods like append and insert.
• Array and AoESA both have a default behavior of setting the capacity to the next power of 2 larger than what is required for a resize, if the capacity is not big enough. This behavior propagates to all the other container classes
• nda is now a property, which returns a slice (of length len(obj)) of the internal data buffer (which has length equal to capacity). This will preserve the old behavior as far as the user is concerned
• dtype was turned into a property in Array, AoESA and VoV. n_dims was for VoV
• core.read resizes the returned array to size obj_buf_start + n_rows_read. Note that this resize could probably be done in the _serializer.read functions in the future (which still return n_rows_read)
• store.read has been simplified, and now just calls core.read after gimme_files. This reduces redundant code
• lh5.iterator no longer returns n_rows_read
• Changed all tests to not expect n_rows_read. Most of them were filling it into _; for the ones that actually had asserts on n_rows_read, these were replaced with asserts on len(obj)
• Table no longer tracks loc, which was a member variable that was more or less used to enable the size to be different from capacity before; since this is now a core feature, this is unnecessary. It does not seem to play any role in our other code packages
• Table had a few methods changed to LGDOContainer methods for consistency