ensures that on PR and push there's a test suite running to verify changes are passing

gets on latest ver to support modern rubies

chore: run Ruby specs on GitHub actions

Bug scenario from @faresd:

> If you create a Release without a description, which is possible by
> Publishing a document and choosing "Publish at a specific date and
> time", the ref returned by Prismic's API will have a null label and the
> Prismic client will fail to parse the entire response.

Because of how the hash construction works, it needs a value for the
key. This makes it fall back to the id of the ref which should always be
present in the scenario where the label is null/nil.

fixes #116

More details:

- https://community.prismic.io/t/release-without-description-causes-error-in-prismic-ruby-client/7514/4

Co-authored-by: Alistair Holt <hello@alistairholt.co.uk>

this undoes the suggestion in
d54dfec
since it's fundamentally different behavior. `fetch` only fallsback to
the second param if the key is missing. but there is a `label` key in
our hash, so it returns `nil`, persisting the `nil.downcase` call. This
makes it so the value properly falls back when `nil`.

It also doesn't downcase the id since that may actually be case
sensitive.

I tested this fix against a codebase reproing the issue and all appears
well.

…ion-fix-2

fix: null label fallback (release w/o name)

# Conflicts:
#	Gemfile.lock

Drops the hashery runtime dependency, which was pulled in solely for
its LRUHash. Ruby's built-in Hash has preserved insertion order since
1.9, so the LRU cache can be implemented directly on top of it: reads
and writes reinsert the entry at the tail, and eviction removes the
head. Removing hashery shrinks the gem's dependency surface with no
change in caching behaviour.

StructuredText::Block::Text#as_html walked the text one character at a
time, escaping each character and concatenating it with +=, so every
character produced a fresh intermediate String and every position hit
the span hashes again. On large rich-text documents this dominated
allocations and GC time.

It now walks span boundaries instead of characters, appending whole
text segments into a single mutable buffer, and hoists the HTML-escape
table and pattern into frozen constants. The generated HTML is
identical. The LRU eviction is also switched to Hash#shift to avoid
allocating a full keys array on every insert.

Extracts span_parser out of structured_text_parser so it is defined a
single time at load. It was declared as a nested `def self.span_parser`,
so every StructuredText fragment parsed redefined the singleton method
on the JsonParser module, invalidating Ruby's global method cache on
each call and churning method-object bookkeeping.

Behavior is unchanged: same body, still public, still delegating to the
sibling link_parser.