[SPARK-1508][SQL] Add SQLConf to SQLContext.

This PR (1) introduces a new class SQLConf that stores key-value properties for a SQLContext (2) clean up the semantics of various forms of SET commands. 

The SQLConf class unlocks user-controllable optimization opportunities; for example, user can now override the number of partitions used during an Exchange. A SQLConf can be accessed and modified programmatically through its getters and setters. It can also be modified through SET commands executed by `sql()` or `hql()`. Note that users now have the ability to change a particular property for different queries inside the same Spark job, unlike settings configured in SparkConf.

For SET commands: "SET" will return all properties currently set in a SQLConf, "SET key" will return the key-value pair (if set) or an undefined message, and "SET key=value" will call the setter on SQLConf, and if a HiveContext is used, it will be executed in Hive as well. 
Hi @concretevitamin, previously I thought the only important thing of a `SchemaRDD` made from an eagerly executed statement (a Hive native command, a set command, or some insertion command etc.) is its side effect, not the content of the RDD itself. But now I do agree that when user call `.collect()` of such an RDD, we should present some meaningful result.

As for the eager evaluation of the RDD content, IMHO, for command `SchemaRDD`s, the RDD contents are either empty or usually generated at the same time when the command is executed (at least I can't find a counter example in the current code base), thus this shouldn't be an issue.

So I think the constraints presented here are:

1. The side effect of a command `SchemaRDD` should take place eagerly;
1. The side effect of a command `SchemaRDD` should take place once and only once;
1. When `.collect()` method is called, something meaningful, usually the output message lines of the command, should be presented.

Then how about adding a lazy field inside all the physical command nodes to wrap up the side effect and hold the command output? Take the `SetCommandPhysical` as an example:

```scala
trait PhysicalCommand(@transient context: SQLContext) {
   lazy val commandOutput: Any
}

case class SetCommandPhysical(
    key: Option[String], value: Option[String], output: Seq[Attribute])(
    @transient context: SQLContext)
  extends PhysicalCommand(context)
  with PhysicalCommand {

  override lazy val commandOutput = {
    // Perform the side effect, and record appropriate output
    ???
  }

  def execute(): RDD[Row] = {
    val row = new GenericRow(Array[Any](commandOutput))
    context.sparkContext.parallelize(row, 1)
  }
}
```

In this way, all the constraints are met:

1. Eager evaluation: done by the `toRdd` call in `SchemaRDDLike` (PR #948),
1. Side effect should take place once and only once: ensured by the lazy `commandOutput` field,
1. Present meaningful output as RDD contents: command output is held by `commandOutput` and returned in `execute()`.

An additional benefit is that, side effect logic of all the commands can be implemented within their own physical command nodes, instead of adding special cases inside `SQLContext.toRdd` and/or `HiveContext.toRdd`.

Did I miss something here?

On the other hand, although I think this solution can be more concise and clean, it may involve some non-trivial changes, so I think we'd better merge this PR as is and make those changes in another PR when appropriate.