Separate TEXT and BLOB types

In most cases it is perfectly fine to interchange use BLOB columns to
represent TEXT columns. Occasionally, however, you will get strange
behavior when comparing BLOB and TEXT columns. The reason that there was
a single type of string column was for compatibility with a foreign
table that was added as a virtual table to Sqlite that did not
distinguish between string types. It is a real headache to debug the
subtle errors that can crop up when you need to compare the different
types of string columns, so we are making them distinct in Scalaqlite
once again.

With this change, queries that return columns of TEXT type will now
return a SqlText object, not a SqlBlob as before. This usually will be a
functional no op because the toString method of SqlBlob should return
the same string as the toString method of the SqlText object that is
instantiated with a ByteArray.
SqliteDb: add parameters to db methods

It is convenient to run SQL queries with formal parameters even for
one-off queries where you don't want to store the prepared statement.
For example, if you have the SqlValue
val foobar = SqlText("foobar"),
it is more convenient to run
db.foreachRow("SELECT * FROM foo WHERE bar = ?1, foobar)(println)
instead of either
db.foreachRow("SELECT * FROM foo WHERE bar = " + foobar.toString)(println)
or
db.prepare("SELECT * FROM foo WHERE bar = ?1")(_.foreachRow(foobar)(println))
and the string concatenation approach is also vulnerable to SQL
injection.

This is a functional no op for all existing calls to these three
methods.

Bonus: remove some unnecessary dummy variables and curly braces
SqliteDb.scala: add mapRows and getRows methods

One often wants to run a query and cache the results in memory. These
two methods should make this a bit more straightforward. The mapRows
and getRows methods are just syntactic sugar to reduce the indentation
by one level whenever one wants a set of all the rows returned by a
query or if one wants to apply a mapping to these rows and cache the
results.

Bonus: I removed the ListBuffer import because it isn't used anywhere.
SqliteDbSpec.scala: replace type affinity test

There was an existing test that checked that BLOB columns were bound as
TEXT that was an artifact of when we only had a single string type for
both BLOBs and TEXTs. That test started failing with the change to bind
BLOBs as BLOBs and to return TEXT columns as TEXT. I've replaced that
test with a new test that verifies that a number of BLOB/BLOB,
BLOB/TEXT and TEXT/TEXT comparisons work as expected. It tests
comparisons between sets of bound parameters, comparisons between bound
parameters and constants and comparisons between db columns.
Merge pull request #9 from eatkins/separateblobtext

Separateblobtext