Add V2 implementation of payments:

Add a new algorithm for finding the liquidity in a payment path. There
is still a reverse and forward pass, but the forward pass starts at the
limiting step rather than the payment source. This insures the limiting
step is completely consumed rather than potentially leaving a 'dust'
amount in the forward pass.

Each step in a payment is either a book step, a direct step (account to
account step), or an xrp endpoint. Each step in the existing
implementation is a triple, where each element in the triple is either
an account of a book, for a total of eight step types.

Since accounts are considered in pairs, rather than triples, transfer
fees are handled differently. In V1 of payments, in the payment path
A -> gw ->B, if A redeems to gw, and gw issues to B, a transfer fee is
changed. In the new code, a transfer fee is changed even if A issues to
gw.

src/ripple/protocol/STPathSet.h

@@ -135,6 +135,23 @@ public:
         return !isOffer ();
     }
 
+    bool
+    hasIssuer () const
+    {
+        return getNodeType () & STPathElement::typeIssuer;
+    };
+    bool
+    hasCurrency () const
+    {
+        return getNodeType () & STPathElement::typeCurrency;
+    };
+
+    bool
+    isNone () const
+    {
+        return getNodeType () == STPathElement::typeNone;
+    };
+
     // Nodes are either an account ID or a offer prefix. Offer prefixs denote a
     // class of offers.
     AccountID const&