3. 10 points

The given implementation of power was not tail recursive because it builds
up numbers that are to be multiplied after the recursive call.  The 
implementation is such that

    power(M, N) == M * (M*M) * (M*M)*(M*M) * ((M*M)*(M*M) * (M*M)*(M*M)) * ...
                   where any of these outer products could be 1, depending on
                   whether the corresponding value of N is even or odd.

Effectively we are accumulating the product by decomposing N into a sum
of powers of 2, as in the binary representation of N, adding multiple (1 or 0)
of 1, 2, 4, 8, ...  and using the corresponding digit to decide whether to
"multiply in" M raised to that power of 2.

To convert to tail-recursive form, we accumulate the product as a third 
argument, multiplying as we go rather than after the recursive call.

power(M, N) = power(M, N, 1);

power(M, 0, Acc) => Acc;

power(M, N, Acc) => odd(N) ? power(M*M, N/2, M*Acc);

power(M, N, Acc) => power(M*M, N/2, Acc);

Notice that we still get the same result, since the accumulator value will 
successively be 

  1 * M * (M*M) * (M*M)*(M*M) * ((M*M)*(M*M) * (M*M)*(M*M)) * ...

where again any of the outer products could be 1, depending on whether
the corresponding value of N is even or odd.