Refactoring to eliminate need for require.js specific code.

This pull request makes the RequireJsSpecRunnerHtmlGenerator and other customizations introduced by the require.js changes unnecessary.  This is done simply by changing the DefaultSpecRunnerHtmlGenerator so that it provides more template variables.  Then we can build the a spec runner template that supports require.js using the DefaultSpecRunnerHtmlGenerator.

The specRunnerTemplate configuration parameter is still available, except now it is an enum and it is used simply to choose pre-built templates.  You can take a look at the enum here: [SpecRunnerTemplate.java](https://github.com/klieber/jasmine-maven-plugin/blob/e5aa554a9a3015c9faff53afd3781d6bf2918892/src/main/java/com/github/searls/jasmine/runner/SpecRunnerTemplate.java)

Here is an example of using the REQUIRE_JS built in template:

```xml
<plugin>
    <groupId>com.github.searls</groupId>
    <artifactId>jasmine-maven-plugin</artifactId>
    <version>${jasmine-maven-plugin.version}</version>
    <extensions>true</extensions>
    <executions>
        <execution>
            <goals>
                <goal>test</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <specRunnerTemplate>REQUIRE_JS</specRunnerTemplate>
        <preloadSources>
            <source>lib/require.js</source>
        </preloadSources>
    </configuration>
</plugin>
```

And the template looks like this:
```html
<!DOCTYPE html>
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=$sourceEncoding$">
  <title>Jasmine Spec Runner</title>
  $cssDependencies$
  $javascriptDependencies$
  $preloadScriptTags$
</head>
<body>
  <script type="text/javascript">
    if(window.location.href.indexOf("ManualSpecRunner.html") !== -1) {
      document.body.appendChild(document.createTextNode("Warning: opening this HTML file directly from the file system is deprecated. You should instead try running `mvn jasmine:bdd` from the command line, and then visit `http://localhost:8234` in your browser. "))
    }

    var specs = $specs$;
				
    var configuration = {
      $if(customRunnerConfiguration)$
      $customRunnerConfiguration$
      $endif$
    };
    
    if (!configuration.baseUrl) {
    	configuration.baseUrl = '$sourceDir$';
    }
    
    if (!configuration.paths) {
    	configuration.paths = {};
    }
    
    if (!configuration.paths.specs) {
    	var specDir = '$specDir$';
    	if (!specDir.match(/^file/)) {
    		specDir = '/'+specDir;
    	}
    	configuration.paths.specs = specDir;
    }
          
    require.config(configuration);
		
    require(specs, function() {
      window.reporter = new jasmine.$reporter$(); jasmine.getEnv().addReporter(reporter);
      if ('$reporter$' == 'HtmlReporter') {
        jasmine.getEnv().specFilter = function(spec) {
          return window.reporter.specFilter(spec);
        };
      }
      jasmine.getEnv().execute();
    });
  </script>
</body>
</html>
```

This change not only simplifies the code quite a bit but it also gives users the power to truly customize their templates how they wish.  For instance, I prefer to use [testr](https://github.com/mattfysh/testr.js) for testing require.js modules rather than wrapping each test in a `define` so the built in template doesn't work for me.  With this pull request now I can just use this configuration:

```
<plugin>
  <groupId>com.github.searls</groupId>
  <artifactId>jasmine-maven-plugin</artifactId>
  <version>${jasmine-maven-plugin.version}</version>
  <extensions>true</extensions>
  <executions>
    <execution>
      <goals>
        <goal>test</goal>
      </goals>
    </execution>
  </executions>
  <configuration>
    <preloadSources>
        <source>lib/require.js</source>
        <source>lib/testr.js</source>
      </preloadSources>
    <customRunnerTemplate>src/test/config/testr_runner.htmltemplate</customRunnerTemplate>
  </configuration>
</plugin>
```

My testr_runner.htmltemplate will look something like this:
```html
<!DOCTYPE html>
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=$sourceEncoding$">
  <title>Jasmine Spec Runner</title>
  $cssDependencies$
  $javascriptDependencies$
  $preloadScriptTags$
</head>
<body>
  <script type="text/javascript">
    if(window.location.href.indexOf("ManualSpecRunner.html") !== -1) {
      document.body.appendChild(document.createTextNode("Warning: opening this HTML file directly from the file system is deprecated. You should instead try running `mvn jasmine:bdd` from the command line, and then visit `http://localhost:8234` in your browser. "))
    }
    var sources = $sources$;
    var sourceDir = '$sourceDir$';
    
    // remove sourceDir and .js extension from each source
    for (var i=0; i < sources.length; i++) {
      sources[i] = sources[i].replace(sourceDir+'/','').replace(/\.js\$/,'');
    }  	
  	
    $if(customRunnerConfiguration)$
    $customRunnerConfiguration$
    $else$
		require.config({
			baseUrl: sourceDir
		});
		
		testr.config({
		  specBaseUrl: '$specDir$'
		});
		$endif$
		
		require(sources, function() {
			var currentWindowOnload = window.onload;

			window.onload = function() {
				if (currentWindowOnload) {
					currentWindowOnload();
				}
				execJasmine();
			};
      function execJasmine() {
      	window.reporter = new jasmine.$reporter$(); jasmine.getEnv().addReporter(reporter);
      	jasmine.getEnv().execute();
      }
    });
  </script>
</body>
</html>
```

The best part of this change is that it no longer is the plugin's responsibility to support all the possible frameworks one might be using.  In fact, we really wouldn't even have to keep a built-in REQUIRE_JS spec runner template in the plugin.  You could simply just provide a wiki page with example templates for using different frameworks.