Space complexity analysis of binary recursive sum algorithm
In a given tree, all the vertices of this tree correspond to binarySum() calls. 
The value of parameter n to binarySum() is halved at each recursive call. 
Also, each recursive call finishes after all its children finish. Thus at each recursive call, number of active calls include all the ancestor calls in call sequence.
Thus when any binarySum() call corresponding to leaves in above call tree is active, its parent, grandparent and so on are still active as well. 
Thus, the depth of the recursion, that is, the maximum number of method instances that are active at the same time, which is always equal to the height of the recursive calls tree is 1 + log$_2$n. 
For example in binarySum() recursive calls tree above, with n = 8, at any of the calls correspnding to leaves,




Why does the depth of recursion affect the space, required by an algorithm? Each recursive function call usually needs to allocate some additional memory (for temporary data) to process its arguments. At least, each such a call has to store some information about its parent call - just to know where to return after finishing. Let's imagine you are performing a task, and you need to perform a sub-task inside this first task - so you need to remember (or write down on a paper) where you stopped in the first task to be able to continue it after you finish the sub-task. And so on, sub-sub-task inside a sub-task... So, a recursive algorithm will require space O(depth of recursion).

@randomA mentioned the Call Stack, which is normally used when a function invokes another function (including itself). The call stack is the part of the computer memory, where a recursive algorithm allocates its temporary data.