Change average_sizes to average_block_sizes

When figuring out what sizes to have in your lmbcs, smbcs or sbct it
is the average block size that is interesting. This is because we
usually want to modify the limits to fit as many blocks as we want in
one carrier. The average carrier size is easy enough to figure out by
just looking at the configurations of the allocators.

This is a backwards incompatible change.
Update docs for sbcs_to_mbcs
Rewrite of recon_alloc:memory

Added a two new options; allocated_types and allocated_instances
that can be used to figure out which allocator types/instances most
data lies in.

Added a new parameter to specify whether you want the current or max
value. This works like sbcs_to_mbcs and you want it for the same reasons.

Change memory(used,_) to use the total block size rather than
erlang:memory(total). This number should be the same, but you can also
get the max value.

These changes are backwards incompatible with the old API
Added current and max options to sbcs_to_mbcs

This is a backwards incompatible change
Add unit conversion for easier comparisons

When working with memory analysis, number often are quite big and become hard
to compare. Therefore it is nice to be able to work in giga/mega/kilo-bytes
depending on what memory you are currently looking at.

This commit adds support for changing which unit is used by all functions that
return a memory size.
Add shorthand recon_alloc:memory/1

Keeps basic backwards compatibility for the sake of it.
Expanding tests for v2.0
Newest rebar version
Dropping parallelism from port_info

This allows better backwards compatibility with all OTP versions
Doc fixes
Trailing whitespace removal
Add recon:get_state/2 to allow custom timeouts

If some calls are epxected to take more than 5s, the current get_state
function is useless. This patch allows a customizeable timeout instead.
Adding binary_memory handling for proc_attrs

This was requested in issue #5 and allows the user to call
`recon:procs_count` and `recon:procs_window` and sort processes by
the amount of binary memory they refer to.
Adding binary_memory handling for recon:info/2,4

This was requested in issue #5 and allows the user to get information on
the total amount of refc binaries used by a process. The code also puts
some scaffolding in place in order to possibly add similar exceptions
later on if need arises.

Tests included.
Fix division by zero on usage/2 call

This always used integers, but with the new unit setting for
recon_alloc, it is now possible to get floating point values in there.

This makes the call handle them.
Bump to version 2.0.0