improved whitespace collapsing rules

I propose the following stricter and more well-defined rules for collapsing and removing whitespace, and have provided a patch to do it:

Any continuous whitespace sequence that **contains at least one newline**, is removed completely
**Reasoning:** Whenever code is separated by a newline, the intention is to improve readability, not to add whitespace ```<div> \n </div> => <div></div>```
**Exception:** If both the start and end is literals one would expect at least a single whitespace to be produced ```A\nB => A B```

Any continuous whitespace sequence that **does not contain a newline**, is collapsed into a single space
**Reasoning:** Whenever two literals or tags on the same line is separated by whitespace, it is arguably intentional (this also solves ```{'A'} {'B'} => AB``` so that it now produces ```A B```.
**Alternative:** Rather than collapse into a single space, add the whitespace as-is? This may also modify the previous exception. Both of these changes are easily accommodated.


#### My opinion on whether to collapse to a single space or not

I'm personally not decided on whether it should collapse all whitespace into a single space, or keep it as is. Collapsing to a single space always produces minimal and predictable whitespace (say if you want to split long lines of text). Keeping whitespace as-is allows mark-down and ```white-space: pre``` to be written inline, but now you're transferring "user editor preferences" (indenting and tabs/spaces) into the final code, intentional or not, and this could easily be accommodated simply by writing it as ```{'  abc  \n'}``` for those uses. So I'm personally leaning towards collapsing to a single space, but not firmly decided.


## Example source:

Sorry for the truly horrible example, but it at least shows most of the different "issues" that exists with regards to whitespace in React today:

```
React.renderComponent(
	<div>    x 
		<span alt="color: #000000" x={123 + 1}></span>w{'awd2'}  {'awd3'}
		
		o
		
		
			l
		
		
		{'awd7'}
	
			{'awd6'}
		
		
		 z    {'awd4'} 
		 
		 w   w   
		   {'awd5'}   
		 x
	</div>,
	document.getElementById('content')
);
```

### What JSXTransformer produces:

In my opinion, a lot of unnecessary and unintentional whitespace is produced simply because the code is arranged into multiple lines for readability. This may sometimes produce unintentional "padding" in the resulting code. ```{'A'} {'B'}``` does also not produce ```A B``` as one would expect.

```
=> " x wawd2awd3 o l awd7awd6 z awd4 w w awd5 x "

React.renderComponent(
	React.DOM.div(null,     " x " ,
		React.DOM.span( {alt:"color: #000000", x:123 + 1}),"w",'awd2',  'awd3',
		" o "+
			"l ",
		'awd7',
	
			'awd6',
		 " z ",    'awd4', 
		 " w   w "   ,
		   'awd5',   
		 " x "
	),
	document.getElementById('content')
);
```

### What my patch produces:

Minimal whitespace is produced and only produced where, in my opinion, one would expect to see whitespace, according to well-defined and hopefully intuitive rules. It also mirrors the original code structure as closely as possible

```
=> " xwawd2 awd3o lawd7awd6z awd4w wawd5x"

React.renderComponent(
	React.DOM.div(null,     " x", 
		React.DOM.span( {alt:"color: #000000", x:123 + 1}),"w",'awd2',  " ",  'awd3',
		
		"o "+
		
		
			"l",
		
		
		'awd7',
	
			'awd6',
		
		
		 "z ",    'awd4', 
		 
		 "w w",   
		   'awd5',   
		 "x"
	),
	document.getElementById('content')
);
```