Since your plane doesn't appear to be reflecting light in the same way as your spheres regardless of the reflection formula you use, I would check that your surface normal is pointing the right way for both objects. It's almost certain your sphere surface normals are pointing inwards of the sphere whereas your plane surface normal is pointing upwards (or vice versa).
Remember: the surface normal is typically defined as always pointing "outwards", that is, if V is the direction of the ray as it hits the geometry, then dot(V, N) < 0 (so that dot(R, N) > 0 where R is the reflected ray). You can define it the other way, with it pointing inwards if you want, but you have to be consistent and make sure this is true for all your geometry, since the reflection formula kind of "needs to know" which way to reflect your incident vector, and that depends on the orientation of the normal vector.
It's fairly easy to enforce if you're only doing reflection, since you can do the dot product check and flip your normal as needed, but it gets messy when you start doing refraction/transparency where non-watertight meshes are physically meaningless (they have no boundary) and you can't flip normals since you need to keep track of which object(s) your ray is currently inside of, therefore you have to be a lot more careful in these situations to make sure your geometry is self-consistent. For opaque reflection you can just hack the surface normal to make it point in whichever direction you need and you're good to go (again, because with reflection only your ray is always "outside" and you know it).
EDIT: if you could show your code for the GetSurfaceNormal() method, that should help track down the bug.
The slowsort algorithm is a perfect illustration of the multiply and surrender paradigm, which is perhaps the single most important paradigm in the development of reluctant algorithms. The basic multiply and surrender strategy consists in replacing the problem at hand by two or more subproblems, each slightly simpler than the original, and continue multiplying subproblems and subsubproblems recursively in this fashion as long as possible. At some point the subproblems will all become so simple that their solution can no longer be postponed, and we will have to surrender. Experience shows that, in most cases, by the time this point is reached the total work will be substantially higher than what could have been wasted by a more direct approach.
- Pessimal Algorithms and Simplexity Analysis