Miscellaneous refactors and updates (#5590)

- Added a new Invariant: `ValidPseudoAccounts` which checks that all pseudo-accounts behave consistently through creation and updates, and that no "real" accounts look like pseudo-accounts (which means they don't have a 0 sequence). 
- `to_short_string(base_uint)`. Like `to_string`, but only returns the first 8 characters. (Similar to how a git commit ID can be abbreviated.) Used as a wrapped sink to prefix most transaction-related messages. More can be added later.
- `XRPL_ASSERT_PARTS`. Convenience wrapper for `XRPL_ASSERT`, which takes the `function` and `description` as separate parameters.
- `SField::sMD_PseudoAccount`. Metadata option for `SField` definitions to indicate that the field, if set in an `AccountRoot` indicates that account is a pseudo-account. Removes the need for hard-coded field lists all over the place. Added the flag to `AMMID` and `VaultID`.
- Added functionality to `SField` ctor to detect both code and name collisions using asserts. And require all SFields to have a name
- Convenience type aliases `STLedgerEntry::const_pointer` and `STLedgerEntry::const_ref`. (`SLE` is an alias to `STLedgerEntry`.)
- Generalized `feeunit.h` (`TaggedFee`) into `unit.h` (`ValueUnit`) and added new "BIPS"-related tags for future use. Also refactored the type restrictions to use Concepts.
- Restructured `transactions.macro` to do two big things
	1. Include the `#include` directives for transactor header files directly in the macro file. Removes the need to update `applySteps.cpp` and the resulting conflicts.
	2. Added a `privileges` parameter to the `TRANSACTION` macro, which specifies some of the operations a transaction is allowed to do. These `privileges` are enforced by invariant checks. Again, removed the need to update scattered lists of transaction types in various checks.
- Unit tests:
	1.  Moved more helper functions into `TestHelpers.h` and `.cpp`. 
	2. Cleaned up the namespaces to prevent / mitigate random collisions and ambiguous symbols, particularly in unity builds.
	3. Generalized `Env::balance` to add support for `MPTIssue` and `Asset`.
	4. Added a set of helper classes to simplify `Env` transaction parameter classes: `JTxField`, `JTxFieldWrapper`, and a bunch of classes derived or aliased from it. For an example of how awesome it is, check the changes `src/test/jtx/escrow.h` for how much simpler the definitions are for `finish_time`, `cancel_time`, `condition`, and `fulfillment`. 
	5. Generalized several of the amount-related helper classes to understand `Asset`s.
     6. `env.balance` for an MPT issuer will return a negative number (or 0) for consistency with IOUs.

src/libxrpl/protocol/SField.cpp

@@ -17,6 +17,7 @@
 */
 //==============================================================================
 
+#include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/protocol/SField.h>
 
 #include <map>
@@ -27,7 +28,8 @@ namespace ripple {
 // Storage for static const members.
 SField::IsSigning const SField::notSigning;
 int SField::num = 0;
-std::map<int, SField const*> SField::knownCodeToField;
+std::unordered_map<int, SField const*> SField::knownCodeToField;
+std::unordered_map<std::string, SField const*> SField::knownNameToField;
 
 // Give only this translation unit permission to construct SFields
 struct SField::private_access_tag_t
@@ -45,7 +47,7 @@ TypedField<T>::TypedField(private_access_tag_t pat, Args&&... args)
 }
 
 // Construct all compile-time SFields, and register them in the knownCodeToField
-// database:
+// and knownNameToField databases:
 
 // Use macros for most SField construction to enforce naming conventions.
 #pragma push_macro("UNTYPED_SFIELD")
@@ -69,8 +71,8 @@ TypedField<T>::TypedField(private_access_tag_t pat, Args&&... args)
         ##__VA_ARGS__);
 
 // SFields which, for historical reasons, do not follow naming conventions.
-SField const sfInvalid(access, -1);
-SField const sfGeneric(access, 0);
+SField const sfInvalid(access, -1, "");
+SField const sfGeneric(access, 0, "Generic");
 // The following two fields aren't used anywhere, but they break tests/have
 // downstream effects.
 SField const sfHash(access, STI_UINT256, 257, "hash");
@@ -99,19 +101,34 @@ SField::SField(
     , signingField(signing)
     , jsonName(fieldName.c_str())
 {
+    XRPL_ASSERT(
+        !knownCodeToField.contains(fieldCode),
+        "ripple::SField::SField(tid,fv,fn,meta,signing) : fieldCode is unique");
+    XRPL_ASSERT(
+        !knownNameToField.contains(fieldName),
+        "ripple::SField::SField(tid,fv,fn,meta,signing) : fieldName is unique");
     knownCodeToField[fieldCode] = this;
+    knownNameToField[fieldName] = this;
 }
 
-SField::SField(private_access_tag_t, int fc)
+SField::SField(private_access_tag_t, int fc, char const* fn)
     : fieldCode(fc)
     , fieldType(STI_UNKNOWN)
     , fieldValue(0)
+    , fieldName(fn)
     , fieldMeta(sMD_Never)
     , fieldNum(++num)
     , signingField(IsSigning::yes)
     , jsonName(fieldName.c_str())
 {
+    XRPL_ASSERT(
+        !knownCodeToField.contains(fieldCode),
+        "ripple::SField::SField(fc,fn) : fieldCode is unique");
+    XRPL_ASSERT(
+        !knownNameToField.contains(fieldName),
+        "ripple::SField::SField(fc,fn) : fieldName is unique");
     knownCodeToField[fieldCode] = this;
+    knownNameToField[fieldName] = this;
 }
 
 SField const&
@@ -145,11 +162,11 @@ SField::compare(SField const& f1, SField const& f2)
 SField const&
 SField::getField(std::string const& fieldName)
 {
-    for (auto const& [_, f] : knownCodeToField)
+    auto it = knownNameToField.find(fieldName);
+
+    if (it != knownNameToField.end())
     {
-        (void)_;
-        if (f->fieldName == fieldName)
-            return *f;
+        return *(it->second);
     }
     return sfInvalid;
 }