JavaScript: что делает Function.call.apply(…)?
Всё просто :). Цель этого трюка — написать обёртку foo(), которая вызывает bar() в указанном контексте context и с переданными аргументами arg1, arg2 без лишних теложвижений.

В традиционном виде, это выглядело бы так

function bar(arg1, arg2) {}

function foo(context, arg1, arg2) {
 bar.call(context, arg1, arg2);
}

Или так для произвольного числа аргументов:

function bar() {}

function foo() {
 var context = arguments[0]; 
 var args = Array.prototype.slice.call(arguments, 1); //делаем массив аргументов для bar
 bar.apply(context, args);
}

Вместо этого салата использовать трюк с call.apply:

function foo() { 
 Function.call.apply(bar, arguments);
}

Работает это так: aplly вызывает Function.call на объекте bar c переданными в foo параметрами. То есть получаем следующее для самого первого примера с context и arg1, arg2: 

bar.call(context, arg1, arg2)

Что нам и нужно.
Зачем: для создания метода объекта, принимающего подстановку «this» как первый параметр.
Function.apply.apply даст другой эффект ввиду того, что apply и call принимают разные параметры.

Зачем на более высоком уровне: приходит в голову только как вариант для построения библиотеки утилит для организации «красивого» вызова и незамусоривания пространства имён

При вызове происходит следующее, если кому интересно:
// в контексте примера
var a={ toString:function(){return 'a'} };
Foo.method(a,1,2,3);

1. в apply передается: объект «Foo.prototype.method», параметры [a,1,2,3]
2. вызывается Foo.prototype.method.call(a, 1,2,3), т.е. Foo.prototype.method от имени объекта a
3. вызывается console.log(a, 1,2,3); т.к. this===a

P.S. исходный пример целиком:
Another trick is to use both call and apply together to create fast, unbound wrappers.
function Foo() {}

Foo.prototype.method = function(a, b, c) {
    console.log(this, a, b, c);
};

// Create an unbound version of "method" 
// It takes the parameters: this, arg1, arg2...argN
Foo.method = function() {
    // Result: Foo.prototype.method.call(this, arg1, arg2... argN)
    Function.call.apply(Foo.prototype.method, arguments);
};