supporting has_many reification based on @lyfeyaj and @NullVoxPopuli 's works

This is based on @lyfeyaj and @NullVoxPopuli 's works. 
What I changed are mainly:
1. Reification for has_many through
2. Add tests and make sure all of them pass
3. Add option mark_for_destruction to mark the has_one/has_many associations that did not exist in the
reified version for destruction, instead of remove them.
4. Disable recursive reification of has_one/has_many associations. See the scenario below for more.
5. Some small tunings like using a hash to reduce the number of loop from n*m to n

### Some notes:

There is a limitation that the Reification will not work properly if the parent of a child can be changed.
Consider this scenario:
1. Create a customer A.
2. Create a customer B
3. Create an order for B.
3. Update A.
4. Change the customer of the order to A
5. Now reify the last version of A.  Ideally we would expect no orders in the reified A.

Recursive reification is not supported. Take the customer, order, and line item model for example, when a customer is reified, the line item is not reified.
Consider this scenario:
1. Create a customer
2. Create an order for the customer with a line item
3. Update the customer
4. Update the line item
5. Now reify the last version of the customer. If we support recursive reification, we would expect to see the line item before the updates in step 4.

There is an assumption in the code that the version_id is always incremental. In reality, it could possibly reach the upper limit of Integer and become 1 again. Thus there is a very rare edge case wherein the reification would not work properly. This is due to selecting 'MIN(version_id)' in the SQL.
Just a quick glance at this makes me think that this could end up being extremely inefficient in cases where a model has a bunch of `has_one` associations.  This will run a complex DB query for every one of those associations in an attempt to find versions that exist.  Can we do some sort of eager loading here with a check to see if the association name matches up to the transaction foreign key name prior to constructing and executing this complex DB query?

I'm not sure if this is even possible, just trying to think of ways to optimize.

I'm guessing it would need to be something along the lines of 
`if self.version_associations.where(foreign_key_name: assoc.foreign_key).any?`

or something to that effect?  I may be off on this but you get the idea, just a verification to check if it even makes sense to run the more complex query.  Maybe this is just as inefficient, and if you believe so you can disregard this comment.