Use tight end positions for lazily closed blocks (sourcePositions)

[dereuromark]

Fixes #141.

With sourcePositions: true, blocks that close lazily when the parser recognizes the following construct (lists, tables, block quotes, definition lists, footnotes) reported pos.end from the parse offset at close time. That included the separator blank line, and for lists the end could equal the next sibling's start:

parse("- a\n- b\n\nAfter.\n", {sourcePositions: true})
// before: bullet_list end = 4:1:9, identical to the following para's start
// after:  bullet_list end = 3:0:7

This change tightens those containers to end at their last child's end position - the convention paragraphs and code fences already follow (paragraph "One.\n" ends at 2:0:4, its trailing newline). Separator blank lines now belong to no block, and sibling ranges no longer overlap. List items are tightened as well, so a parent list's range always contains its last item (previously the tightened list could end before the lazily closed item).

Same approach as the earlier end-position fixes in #83 (list_item) and #82 (section); those behaviors are unchanged.

Tests: new cases in src/parse.spec.ts assert exact start/end for block quote, table, bullet list, definition list, and footnote, plus the following paragraph's positions and non-overlap/containment. One expectation in test/sourcepos.test encoded the old overshoot (list_item (1:2:1-2:1:5) - ending at the first character of the next item's line) and was updated to the tight value. Full suite passes.

[jgm]

Instead of having a separate function just for lists, why not apply the tightenContainerEnd function to the list_item nodes? Then, when we get to the list nodes, the last child will already have an appropriate end position and we won't need to recurse into its children...

[dereuromark]

You were right that the recursion was unnecessary: since -list_item events always fire before their parent -list, the last child already carries a tight end position by the time the list closes. So getLastBlockEnd and the separate list function are gone, and the fallback loop over earlier siblings is gone too - if the last child has no position, we now leave the container's end untouched rather than guessing from an earlier sibling.

The whole thing is now a single small function:

const tightenContainerEnd = function(node: Container): void {
  const lastChild = node.children[node.children.length - 1];
  if (node.pos && lastChild && lastChild.pos) {
    node.pos.end = lastChild.pos.end;
  }
}

I kept it as a named function rather than inlining the conditional, since it is called from five handlers (list, list_item, block_quote, table, footnote). Full suite still passes.

[jgm]

Much better!