Previously, all nodes rejected transactions with irrelevant signatures
always. Now, this is still true, except if a transaction with irrelevant
signatures is included in an otherwise valid block: then the transaction
is accepted even though it fails the soft check.

Test that a fully validated transaction to transfer money requires the
linked authority, or a parent, but not a child.

This adds a way to review and potentially alter a transaction generated
by the test framework, prior to pushing it.

We now enforce a recursion depth limit for authority checks. If the
limit is hit, it silently rejects the authority.

Implement automatic signing of transactions in the test framework.
Currently disabled, as it's not yet working

We now check authorization of transactions when they come in as pending,
and again when we apply them in some block (either when generating the
block or when applying it). When applying the transactions in a block,
we check auth for all transactions in the block prior to processing any.

To check auth, we first scan all of the declared authorizations, and
check that the authorization is sufficient to grant permission for the
given account to execute the given message type (TODO: look up the
actual required permission level rather than just assuming it's
'active'); then, check that the transaction bears signatures to confer
the declared authorization.

- todo: some of the test are broken because the tests were malformed in
the first place (missing auths)

The testing framework still used "database" to refer to the blockchain, which doesn't make sense since we split the blockchain class from the database class. This commit updates the names/docs in the
test framework to use chain instead of database as appropriate.

Define types, objects, and indexes necessary for proxied voting on
producers. Also, perform some necessary refactoring, as the old code
assumed the only way votes could be cast would be direct, not by proxy.

Now we calculate the round changes and store them in generate_block.

Progress:
- When an account adds/removes stake, we now update votes for its
approved producers
- Name map<AccountName, AccountName> as RoundChanges, and define
operator- such that RoundChanges = ProducerRound - ProducerRound

Test the vote updates, making sure that producer votes are updated when
an account adds stake

TODO: Calculate the producer round changes in generate_block and add to
block header

- Rename config::ProducerCount -> config::BlocksPerRound
- Add new config::VotedProducersPerRound = 20
- Split up staked_balance_objects.hpp moving ProducerVotesObject to
producer_objects.hpp

This new interface allows the chain_controller to request a fresh round
of producers and request the producers' median voted blockchain
configuration.

Net yet complete, but integrated sufficiently to get the tests to pass.

And rename it to chain_initializer_interface

Aftermath of 55a84709 -- the chain
library no longer ever touches genesis_state_type; this type is only
recognized by native_contract now, so move its files from the chain
library to the native_contract library.

OK, so this turned out to be a **massive** refactor that I thought I'd
never finish, and no, I don't remember everything that changed here, but
I think it all worked out to be better than before, and almost all of it
was fairly necessary/the best of available options. Whew. I am SO glad
this is finally done.

High level goal: Continue refining the native contracts (ref #15),
specifically
walling off their state into their own contract DBs rather than globally
shared (read: stuff that race conditions are made of) general blockchain
state.

The first real change I made in this commit, which precipitated the
avalanche of changes that followed before the project became consistent
again, was to move the account balance out of account_object (globally
shared) to an object known only to the Eos Contract, thus eliminating
the possibility of race conditions/nondeterministic behavior.

The trouble is, balances are set at genesis. Genesis is processed by
chain_controller. chain_controller cannot know about balances, since
those are an abstraction defined on top of the Eos contract, which is an
abstraction defined on top of chain_controller. So all of genesis had to
be reimagined, and quite a lot of architectural changes had to be made
in order to create a logically consistent solution.

Changes (probably incomplete):
 - Fix up notifications within the native contract to support
precondition validation as well as application

 - Add notify handlers for CreateAccount to Eos and Staked Balance
contracts

 - Move account's liquid balance of EOS from account_object to
BalanceObject

 - Replace {producer,account}_object::id_type with AccountName most
everywhere except block_header, which still contains a
producer_object::id_type (potentially in violation of protocol
standards, but I want to confirm that before fixing it)
   - Reason: The name is not significantly slower, as it's fixed length so
no heap allocs, and it simplifies the code in quite a few places by
allowing us to look up objects directly rather than indirectly by
looking up an ID to get an intermediate object to get a handle for the
object we really wanted

 - Replace native_system_contract_plugin with native_contract library
   - Reason: The plugin was getting in the way. The native system
contract C++ implementation is simply too fundamental unless/until we
have a scripted implementation that works until the native
implementation gets installed

 - Completely reimagine genesis initialization, taking it largely out of
the hands of chain_controller and putting it in the hands of
native_contract
   - Reason: chain_controller understands relatively little about
genesis. It understands global_property_object and producer_object, but
not BalanceObject or StakedBalanceObject, etc... It also doesn't
understand the native_contract, and things like installing the native
contract, setting up accounts/balances, etc. all need to be handled by
something... native_contract is the most logical place to put it.

Sorry for the enormous commit... alas, this was the first time I got it
all building again and passing tests in days.

This completes the refactor (to a buildable/tests passing state) from my
last commit.

Rename database class to chain_controller, as this class manages
blockchain state and operations. Database was a misnomer.

Next step: make chain_controller a free-standing class, rather than
having it inherit from chainbase::database. This should give us a better
architecture, especially for testing, going forward.

The system contract C++ implementation is now in a plugin rather than
directly on database.

Note that testing_database installs this implementation on the testing
database, even though the test framework does not use appbase or appbase
plugins.

The simulated network was recursively calling push_block when
propagating blocks, which caused a lock timeout. Fix this issue by not
pushing a new block to the database that created it.

Also, replace the currently_propagating_block flag with boost's slot
blocker.

- absent signature verification

All tests now pass again. :)

Dunno what happened, but I don't have time to fix it right now.

Fix the stuff that broke in merge.

Also remove transaction_evaluation_state and the size_checker program.

- Cleaned out some cruft
- Added some new macros to remove boilerplate
- Added some more test cases

Add a testing_network class to emulate a P2P network ferrying blocks
between databases.

Add some test cases exercising databases syncing with the
testing_network and resolving forks.