Improve account_balance indexing

[theoreticalbts]

The account_balance indexing is currently defined as:

  typedef multi_index_container<                                                                                                                                                                                                         
     account_balance_object,                                                                                                                                                                                                             
     indexed_by<                                                                                                                                                                                                                         
        ordered_unique< tag<by_id>, member< object, object_id_type, &object::id > >,                                                                                                                                                     
        ordered_unique< tag<by_balance>, composite_key<                                                                                                                                                                                  
                                            account_balance_object,                                                                                                                                                                      
                                            member<account_balance_object, account_id_type, &account_balance_object::owner>,                                                                                                             
                                            member<account_balance_object, asset_id_type, &account_balance_object::asset_type> >                                                                                                         
                        >,                                                                                                                                                                                                               
        ordered_non_unique< tag<by_account>, member<account_balance_object, account_id_type, &account_balance_object::owner> >,                                                                                                          
        ordered_non_unique< tag<by_asset>, member<account_balance_object, asset_id_type, &account_balance_object::asset_type> >                                                                                                          
        >                                                                                                                                                                                                                                
     > account_balance_object_multi_index_type;

The by_account index is redundant, as the by_balance index (which could be better named by_account_asset) can answer any query the by_account index can.

In addition, an index by (asset_type, balance) is required to support top_n authority. Again, the by_asset functionality can be assumed by this new index.

So the solution is:

• Rename by_balance to by_account_asset
• Remove by_account and rewrite logic to use by_account_asset instead
• Expand by_asset to composite key on (asset_type, balance)

The equal_range() of boost::multi_index_container will be useful for the new logic.

[theoreticalbts]

We need to have composite_key_compare like this:

        composite_key_compare<
           std::less< asset_id_type >,
           std::greater< share_type >,
           std::less< account_id_type >
        >

so that the ordering is increasing asset ID, decreasing balance within an asset ID, and increasing account ID. So effectively the "rich list" for each asset, with ID as tiebreaker (a lower ID is ranked above a higher ID with equal balance).

[theoreticalbts]

That was easier than I expected. Apparently by_asset wasn't actually being used by anything!