feat: Character-level diffs

[afnanenayet]

Up until this commit, diffsitter has computed diffs by directing
comparing the equality of the text of two nodes. This means that if two
nodes had text content that was unequal at all, the contents of that
entire node would be considered a difference.

As a concrete example, consider the two snippets:

fn example_a() {}

fn example_b() {}

The diff would see the text corresponding to the identifiers for each
function are different, so the corresponding diff would be:

-example_a
+example_b

Because we just check if "example_a" == "example_b". What we really
want is:

-a
+b

We are able to achieve this by breaking up each node into Entry
objects that correspond to a single unicode grapheme, so when the diffs
are computed, they are on a per-grapheme basis rather than at a per-node
basis. Of course, the actual diff mechanism is generic, so we only have
to modify how the Entry object is created, and the diff and hunk
construction mechanisms remain unchanged.

This PR also updates the equality check to account for the type of a node, so a
comparison between:

fn some_function() {}

fn r#fn() {}

would treat the different fn blocks as different based on whether they are a
keyword or as part of an identifier.