I've modified the escape-text function escape text based on wether or
not it exists in an escapable range.

This commit implements a proof of concept that protects the first
escapable character and will not pass check.

In this version, we no longer need to split nodes in order to protect
them if we also want them to be continuous. I've taken the XSL template
"escape-text" and modified it so that it takes in three new parameters:

1. `pos`..........the position of the current character
2. `protect.pos`..a space-separated list of starting positions for
   protection
3. `protect.end`..a space-separated list of ending positions for protection

I've also added three new helper templates to handle list contents:

`peek` returns the top of the list, `trim` trims off the first element
of the list (or returns the value if it's not a list), and `adjust-range`
trims a list depending on if the current value is within range.

There's a lot of printing here because I wasn't too confident with
debugging, but based on my test in inst/extdata/xml_protect.xml, it
produces results correctly.

I had initially found a tokenize template and had contacted the author
about license information (she gave permission):
<https://exslt.github.io/str/functions/tokenize/str.tokenize.template.xsl.html>

When I was working with it, I found that the function exists as part of
libxml because it bundles EXSLT functions, which allows me to do this
easier and more efficient by tracking and modifying a single index
instead of a pair of strings.

This will address #105

…into fix-105-unprotect

The square bracket _should_ be escaped since it's outside of the
protected range.

This begins to address limitations of the attribute-based protection
by providing a way to separate and rejoin nodes that were previously
split.

The previous iteration was not quite correct because it had assumed that
the sourcepos would match up exactly with the protection ranges, but
these were two separate numbers.

This does the following:

1. when a protected range spans the entire node, then it is labeled "asis"
2. `split_sourcepos()` now reflects the actual end of the sourcepos
   instead of the computed end
3. an awkward catch for single nodes in `join_split_nodes()` is now
   eliminated
4. `join_split_nodes()` no longer re-comuputes the protected ranges from
   the sourcepos

This allows us to search for internal nodes using their identities