remove lvalue-qual Future::unwrap()

Summary:
This is part of "the great r-valuification of folly::Future":

* This is something we should do for safety in general.
* Several of folly::Future's methods are lvalue-qualified even though they act as though they are rvalue-qualified, that is, they provide a postcondition that says, in effect, callers should act as though the method invalidated its `this` object (regardless of whether that invalidation was actual or logical).
* This violates the C++ principle to "Express ideas directly in code" (see Core Guidelines), and generally makes it more confusing for callers as well as hiding the actual semantics from tools (linters, compilers, etc.).
* This dichotomy and confusion has manifested itself by some failures around D7840699 since lvalue-qualification hides that operation's move-out semantics - leads to some use of future operations that are really not correct, but are not obviously incorrect.
* The goal of rvalueification is to make sure methods that are logically rvalue-qualified are actually rvalue-qualified, which forces callsites to acknowledge that rvalueification, e.g., `std::move(f).unwrap(...)` instead of `f.unwrap(...)`. This syntactic change in the callsites forces callers to acknowledge the method's rvalue semantics.

Reviewed By: yfeldblum

Differential Revision: D9329273

fbshipit-source-id: fbcda4310fe4d008b7c7595d320d15e3581f09c1

folly/futures/Future.h

@@ -1101,13 +1101,6 @@ class Future : private futures::detail::FutureBase<T> {
       enable_if<isFuture<F>::value, Future<typename isFuture<T>::Inner>>::type
       unwrap() &&;
 
-  template <class F = T>
-  typename std::
-      enable_if<isFuture<F>::value, Future<typename isFuture<T>::Inner>>::type
-      unwrap() & {
-    return std::move(*this).unwrap();
-  }
-
   /// Returns a Future which will call back on the other side of executor.
   ///
   /// Preconditions:

folly/futures/test/UnwrapTest.cpp

@@ -24,7 +24,7 @@ using namespace folly;
 TEST(Unwrap, simpleScenario) {
   Future<int> encapsulated_future = makeFuture(5484);
   Future<Future<int>> future = makeFuture(std::move(encapsulated_future));
-  EXPECT_EQ(5484, future.unwrap().value());
+  EXPECT_EQ(5484, std::move(future).unwrap().value());
 }
 
 // Makes sure that unwrap() works when chaning Future's commands.