Your code is nicer though
As you pointed out, just by putting an outside closure there one could protect it from namespacing:

(function() {
  (function trav(node, val) {
      if(node == null) return trav;
      node.selected = val;
      return trav(node.parent, val);
  })(nodePrev, false)(nodeNew, true);
})();

However, I’m not sure about the performance of that code.

(function trav(node, val) {
    if(node == null) return trav;
    node.selected = val;
    return trav(node.parent, val);
})(nodePrev, false)(nodeNew, true);

You’ll notice the use of the name “trav” right after the function keyword allows you to refer to it by name inside itself for the recursion (as well as the chainability “return”). I’ve read that arguments.callee is less performant than a named function reference, which would especially be an important factor in regards to recursion. I’ve never tested this myself, and honestly, I usually use “arguments.callee” in these cases, but I figured it was helpful to contrast it with a slight alternative.

The only downfall here is that with only the above, “trav” becomes a defined function reference outside the function block scope in question. You could of course wrap the above in an outer “(function(){…})();” scoping block, and get both better performance as well as namespace protection, preventing “trav” from leaking out into the outer variable scope.

http://matt.might.net/articles/implementation-of-recursive-fixed-point-y-combinator-in-javascript-for-memoization/

  (function() {
    var selectPath = function(node, val) {
      if(node == null) return;
      node.selected = val;
      return selectPath(node.parent, val);
    };
    selectPath(nodePrev, false);
    selectPath(nodeNew, true);
  })();

That way you’d be avoiding stepping into some other defined variable with the same name.