This PR adds a new shared library for doing local name binding, and applies it to Ruby and Rust.

The interface to the library is inspired by a similar unreleased library created by @asgerf, but unlike that library, this library supports sibling-based shadowing as known from Rust:

let x = 1;
let x = x + 1;     // shadows `x` above, but `x` in the RHS still refers to the above
println!("{}", x); // refers to the shadowing `x`

The implementation handles sibling shadowing much simpler than the current Rust implementation (which also has a bug, see one of the added tests), by treating shadowing sibling declarations as defining a new scope, and then letting all subsequent statements be children of that scope. That is, when looking up names by going up the AST, we rewrite the AST above to (eliding leaf nodes):

      let x = 1;
       /      \
     x + 1   let x = x + 1
                   |
            println!("{}", x);

Note how the RHS is moved away from let x = x + 1 to ensure that it resolves to the preceding declaration.

DCA for Rust and Ruby are good; no result changes but a minor speedup (for Rust).