Rewrite dependency algorithm

Basically, dependency solving is faster, limits costly package lookups
(fetching information from the AUR can take a long time), and should
solve the "Prelude.head: empty list" problem.

The new dependency algorithm uses as concrete `Package` type for
simplicity. Packages can be installed in two ways: pacman, or
building (represented by the `Buildabe` type, formerly a typeclass).

To flexibly resolve dependencies, it uses a `Repository`
type, which provides packages (e.g. from the AUR, ABS tree, or pacman
repositories). Multiple repositories can be combined to search one
before the other.

The algorithm starts by compiling a map of package names. For each
dependency, it searches the map and then the outside repository for
a package. Once a package is found, it checks the version to make sure
it satisfies the dependency. If the package needs to be added to the
map, its dependencies are recursively added. After all the needed
packages are added to the map, they are put into a graph and topsorted
into the required install order.

Package groups and packages provided by another one (called virtual
packages before) are not handled. If they are in the pacman repos,
pacman will handle them. If they are in the AUR, this method does not
handle them (but neither could the previous method). Hopefully this
will be fixed soon.

Error messages are a little tricky because I don't speak 11 languages.
`getRealPkgConflicts_1` and `getRealPkgConflicts_2` are both used as
they were originally. `getVirtualConflicts_1` (which has a terrible
English message, in my opinion) is hijacked to indicate a dependency
could not be found. `getVirtualConflicts_2` and `getVirtualConflicts_3`
are not used.
Export `(<$>)` and `asks` from Aura.Monad.Aura

`(<$>)` is cleaner and more readable than ``fmap`` when used as an
infix operator.

`asks` is also useful. Instead of
> action = f `fmap` ask >>= \x -> do ...
you can do
> action = asks f >>= \x -> do ...
Update installation of packages

The user interface should be the same as before, but installation
now uses the Package and Repository types.

After a bit of user interaction, dependencies are calculated and the
resulting packages are split into pacman and buildable packages. The
pacman packages are filtered (with pacman) to remove up-to-date
packages and installed all at once with pacman. The buildable packages
are also filtered (but explicitly installed packages are kept) and
built one-at-a-time. In the future, moving to a libalpm backend will
eliminate this distinction and simplify the process.
Update -A commands

Installing and checking dependencies with -A now works. When installing
AUR packages, dependencies are first searched for with pacman and then
within the AUR. For our purposes, packages in the pacman repos have no
dependencies, because pacman can handle them all. In addition, querying
packages is more cleanly separated from installing them.
Remove ABS tree from settings

Although Haskell is a lazy language, IO actions are strictly sequenced.
So, the ABS tree was calculated and stored whether -M commands were
used or not. Now we have more control over when the ABS tree is loaded.
Update -M commands

Installing and checking dependencies with -M now works. When installing
ABS packages, dependencies can be resolved in two ways. By default,
they are resolved using pacman packages. If `--absdeps` is specified,
they are resolved using the ABS tree and then using pacman packages.
This means that the user can specify which dependencies to install by
syncing them in the ABS tree first. All ABS dependencies are installed
even if they are up-to-date.

Dependency checking with -Md now has the same behavior. In particular,
dependency checking is affected by `--absdeps`.

Querying the ABS tree is handled with a separate `PkgInfo` type.
Remove uneeded files

Removed "Aura.Graph", "Aura.Package.Types", and "Aura.Package.Virtual".
Add GHC options

`-Wall` will make the source cleaner. `-O2` makes aura faster.