curry anywhere with placeholder argument

> extending this whole placeholder concept to all our currying

Well, for better or worse, here is an attempt.

+ First, I realize this a pretty big change. If it is not accepted, totally cool, hopefully its existence still somehow furthers the ramda cause even in defeat
+ I saw 0.6 was about ready to go, I doubt this would go in there, but I figured I better submit the PR before I found myself writing a `curry0` function (more on that in a bit)
+ got rid of `op`
+ It doesn't seem to be Ramda style to include inline comments. I have some in there (with at least one typo that I now see) but we can obviously get rid of those
+ I had to update `checkForMethod` to return a function with the proper arity
+ `curry2` is updated, and now `curry1` is a thing! Despite being a bit ugly, my totally unscientific testing showed it is (unfortunately) something like 5-10% faster. I did not rewrite `curry3`
+ `R.__` is defined as an object that we can test for with ===, as defining it as `undefined` or `void 0` can cause problems if someone actually wants to use `undefined` and ramda mistakes it for our placeholder.
+ In this implementation, I would say `R.__` is maybe not so much a "placeholder" as a "skip" concept. Passing in one or more `R.__` with no actual arguments just gives you back the function you already had.

Alright, probably could go on but I think that is a enough to get the discussion started. Thanks!
yes, the only justification i can imagine here is if they get the function back and want to pass a placeholder again, which seems a little crazy