Updates FnPartials to move stored_arg when rvalue

Overloads `operator|` for rvalue and lvalue `Pipeable`s and downcasts
accordingly.

Adds rvalue-reference qualified overloads to FnPartial `operator|`
that calls `std::move(stored_arg)` when creating the actual iterable
object.

This allows a move-only callable to get passed by value, but only moves,
all the way into the itertool.

```
// both should work
iter::some_itertool(sequence, MoveOnlyCallable{});
sequence | iter::some_itertool(MoveOnlyCallable{});
```

I did attempt passing a `std::reference_wrapper` from the `FnPartial`
but the iteration happens after the `FnPartial` is destroyed, So the
following is unsafe:
```
// unsafe, wrong
template <typename Container>
auto operator()(Container&& container) const {
  if constexpr (std::is_copy_constructible_v<T>) {
    return F{}(stored_arg, std::forward<Container>(container));
  } else {
    return F{}(std::ref(stored_arg), std::forward<Container>(container));
  }
}
```

Setting the stage to fix #89

Author: Ryan Haining

cppitertools/internal/iterbase.hpp

@@ -353,9 +353,14 @@ namespace iter {
     template <typename ItTool>
     struct Pipeable {
       template <typename T>
-#if  defined(__GNUC__) && !defined(__clang__)
-        [[gnu::no_dangling]]
+#if defined(__GNUC__) && !defined(__clang__)
+      [[gnu::no_dangling]]
 #endif
+      friend decltype(auto) operator|(T&& x, Pipeable&& p) {
+        return static_cast<ItTool&&>(p)(std::forward<T>(x));
+      }
+
+      template <typename T>
       friend decltype(auto) operator|(T&& x, const Pipeable& p) {
         return static_cast<const ItTool&>(p)(std::forward<T>(x));
       }
@@ -378,11 +383,17 @@ namespace iter {
      protected:
       template <typename T>
       struct FnPartial : Pipeable<FnPartial<T>> {
+        static_assert(!std::is_reference_v<T>);
         mutable T stored_arg;
-        constexpr FnPartial(T in_t) : stored_arg(in_t) {}
+        constexpr FnPartial(T in_t) : stored_arg(std::move(in_t)) {}
 
         template <typename Container>
-        auto operator()(Container&& container) const {
+        auto operator()(Container&& container) && {
+          return F{}(std::move(stored_arg), std::forward<Container>(container));
+        }
+
+        template <typename Container>
+        auto operator()(Container&& container) const& {
           return F{}(stored_arg, std::forward<Container>(container));
         }
       };
@@ -403,10 +414,15 @@ namespace iter {
       template <typename T>
       struct FnPartial : Pipeable<FnPartial<T>> {
         mutable T stored_arg;
-        constexpr FnPartial(T in_t) : stored_arg(in_t) {}
+        constexpr FnPartial(T in_t) : stored_arg(std::move(in_t)) {}
 
         template <typename Container>
-        auto operator()(Container&& container) const {
+        auto operator()(Container&& container) && {
+          return F{}(std::forward<Container>(container), std::move(stored_arg));
+        }
+
+        template <typename Container>
+        auto operator()(Container&& container) const& {
           return F{}(std::forward<Container>(container), stored_arg);
         }
       };
@@ -469,10 +485,16 @@ namespace iter {
       template <typename T>
       struct FnPartial : Pipeable<FnPartial<T>> {
         mutable T stored_arg;
-        constexpr FnPartial(T in_t) : stored_arg(in_t) {}
+        constexpr FnPartial(T in_t) : stored_arg(std::move(in_t)) {}
 
         template <typename Container>
-        auto operator()(Container&& container) const {
+        auto operator()(Container&& container) && {
+          return IterToolFnOptionalBindSecond{}(
+              std::forward<Container>(container), std::move(stored_arg));
+        }
+
+        template <typename Container>
+        auto operator()(Container&& container) const& {
           return IterToolFnOptionalBindSecond{}(
               std::forward<Container>(container), stored_arg);
         }