Massive refactor #N for borrowing iteration

New "Cursor" abstraction returns a tuple of references to a byte slice
key and associated Value type. This tuple replaces Entry (removed), and
the cursor's immutable get() allows the merger heap to use the cursor
directly for ordering.

WIP, several bugs likely remain, but unit tests pass.

Lots of WIP on new lending "Cursor" abstraction

Added merger of cursors and of duplicates. IntoIterator implementations
for Cursors which maintain a local copy of the value modified to use
take() instead of .clone()ing values. Getting closer to zero copy.

Merger uses Ord wrappers on the cursors themselves to provide duplicate
sorting or unsorting, which removes the need to copy values to wrap them
in an ordering wrapper.

Overall, code is getting simpler with fewer copies, a win-win.

Add "Cursor" abstraction for lending iterator.

Uses immutable get() method to return borrowed key, value pair, mostly
to avoid copying keys to provide sorting in merger.

Rearranged source code to be more granular

Also made a bunch of other changes

Refactor, again (WIP)

Break up some larger files into smaller chunks, also decouple Iter
and Iterator again, in favor of implementing IntoIterator for
Iter implementations.

Still a few remaining nits to work out -- the IntoIterator trait
isn't coming into scope where I expect it, so may need to back
off of `impl Iter` in favor of an associated type on Source which
requires IntoIterator.

Add map capability to Source, SeekableIter

Correct RangeIter trait bounds

Like get_range(), only PartialOrd<[u8]> is required, not AsRef<[u8]>

Implement dyn-compatible source variant.

With appropriate boxing, allows creation of dynamically-dispatched
sources for heterogeneous collections of sources.

Refactor again to take advantage of impl Trait.

Will pursue mixed mergers through methods other than direct dyn
Compatibility of Source trait.

Address div_ceil clippy warnings

Reduce lifetime proliferation.

Makes Source trait non-dyn-compatible again, but an improvement in
reducing lifetimes and function generics.

WIP #2 - Remove Item associated type from Source

WIP attempt to make dyn compatible source abstraction.

Streamline sorter 'write' method again.

Rename merge_func, dupsort_func sources, iterators.

cargo-clippy fixes

Refactor to allow for dyn-compatible Source, iteration over arbitrary
types.

Update .gitignore

Rename Iter -> SeekableIter

Make Iter, Source generic on item type

This is to allow mapping items to higher level types while preserving seek
functionality.

Fix Fileset bugs

Handle relative paths in fileset file, start last_reload at 0/epoch

Add Debug derives to mtbl::{Fileset,Reader}

Various API tweaks

Avoid need to import memmap, expose fileset

Add filter with seek capability

Simplify merge_func, dupsort helpers

Add the iterator wrapper methods to the Iter trait, allowing
the source implementations to apply them to the inner iterator
rather than constructing the implementation structs directly.

Hide inner Entry structure

Refactor fileset

Implement lazy loading on first use and error reporting.

Multiple cleanups; flesh out sorter logic

Give merge function a mutable reference to data only, to prevent
accidental mangling of keys.

Implement source on Vec<Entry> for sorter; migrate tests eventually.

More cleanup from "impl Iter" based sources

Not having to explicitly name the iterator return types saves
the need to name the returned iterator's reference lifetimes, if any.
This removes the need to implement Source on a reference to a type
in order to assign `&self` a lifetime.

Once again, we can implment Source on an owned type reliably, saving
the need for pointer indirections.

Refactor Source without object safety

WIP: attempt to refactor Source without object safety

WIP: sorter implementation

block_builder: use Vec::new() instead of Vec::default()

block_builder: remove last bit of custom varint code

Add merge_func and dupsort_func methods to Source

More refactoring, natch.

Replace DefaultSource with generic implementation on IterSource.

Ditch "prelude" import -- IterSource no longer required, importing
mtbl::Source is sufficient to use Source trait.

first cut of fileset support

Remove blanket dead code warning suppression

reader: support uncompression

Weave CBuf into blocks for compression

Make compression CBuf type generic

Write index block with length, crc

Remove dead code

Add file reader, rudimentary mtbl_dump

tests: use small blocksize in rwtest to exercise index

block: use little-endian fixed representations

Consistent with C mtbl

reader: handle seeking past end of index block

writer: fix logic error in offset tracking

Refactor block code for clean-up, tests, seek() fixes

increase size of rwtest data

Update API layout to use prelude

Add test for range iter, add missing linear search step to
BlockIter seek

reader: remove debug print and unused CRC decoding

cargo-clippy lints

Give ReaderIter a Reader Clone for flexibility

WIP: working reader, with test

Squashed several bugs, will have to squash `.expect()`s next.

iter.rs: cargo fmt

writer: Move index update to data block write

Fixes missing index write on last block.

Refactor reader code around Arc<impl AsRef<[u8]>>

API currently named 'DataSlice' provides convenient views of
ranges / slices of the underlying buffer, avoiding lifetime
entaglements.

experimental first cut at reader -- not working

writer: write in-progress block

metadata: read from file-like object instaed of buf

Flesh out writer, block builder, requirements

move block result, error to main lib

add metadata, compression

Refactor block, block_builder for readability, magic numbers

Fix "off by 4" bug caused by double call to block builder finish.

Break iter and source into separate modules.

source.rs: Remove unneeded GenSource trait

Rename GenWrap to BoxWrap for clarity.

Rename GenericSource -> BoxedSource

Flesh out 'generic merger' test

Generic sources working after big refactor.

Root cause was Box<dyn Trait> defaults to Box<dyn Trait + 'static>,
leading to the 'static lifetime "infecting" the generated iterators,
causing the borrow to last beyond the end of the function which dropped
the box or its containing structure.

The quick fix was to inject and add an explicit lifetime to the Box.

While tuning that fix, opted to inject lifetimes by implementing
Source methods on references. This tracks more with the C mtbl API,
where:

m = mtbl_merger_init(mopt);
/* populate m */
mtbl_merger_source(m);

is roughly mirrored by:

let m = mtbl::Merger::from(...);
let source = &m;

generic sources working, sort of, in test

WIP experiment dyn source

Lifetime making it hard to test, possibly implement at all

Refactor Source trait hierarchy

Source implements get/prefix/range, and is a subtrait of
IterSource which implements only iter(). The Default
implementation is now another subtrait of IterSource.

This avoids several of the previouas `Source<'a> + Ranges<'a>`
and 'Source<'a> + DefaultRanges' type constraints, and
simplifies type paths.

General cleanup, cargo-clippy fixes

pull out the non-working generic source bits

WIP of attempt to make a generic source

Add generic source wrapper for mixed mergers

fixed lifetime issue! ?

WIP commit: attempt to make Source object safe

Use associated iterator types instead of `impl Iter`. Move
get, get_prefix, get_range to separate "Ranges" trait, with
a generic default implementation based on iter() enabled by
"DefaultRanges" trait.

WIP due to one pesky lifetime issue.

merger: Remove all internal use of Box<dyn Iter>

Adding Iter implementation for Box<dyn Iter> allows it
to be used as a concrete type in case of a mixed merger.

Add support for Boxed dyn Iter objects

merger: remove Source paramater from Iter template.

Beginnings of reader and writer

Another refactor: back to mtbl C idioms

Iter (includes seek + iterator), static entry type, Source,
merger, etc.

map values only; generic keys too complex

Seekable: relax Ord requirement on keys

This allows implementations to return Result<> types to propagate
errors. Those errors will need to be handled prior to merging
or coalescing.

SeekableVec: relax Copy requirement to Clone

Modify filter_map to only map values

Mapping keys requires a conversion on seek from the
mapped key to the inner key. Since the keys are passed
to seek by reference to avoid moves, this complicates
consuming the key for a full conversion to the inner
key.

For now, restrict mapping to values only. This required
changing the filter function signature to take a reference
to the key so its caller could retain the key for returning.

cargo-clippy fixes

Remove redudant Some(foo()?).

Make PartialOrd more canonical.

Add coalesce (merge function) support

SeekableVec: add value type.

Refactor imports for visibility.

Move SeekableVec to module for test support

Refactor to generic Seekable IntoIterator

Remove lender dependency

format iter.rs

Convert AsRef template functions to use impl AsRef

iter: Genericize repeated IntoIterator implementations

Introduce 'Seekable<T: Entries>' wrapper to bring common
'return Iter<T>' logic to one place.

Entries::filter_seek -> Entries::filter

No longer need separate name due to Iterator co-implementation

Rename Iter to "entries" to avoid confusion with iterator.

Entries implements IntoIterator.

Iter -> Entries, prep for Iter: IntoIterator