Transaction: restrict TxIn/TxOut constructor params

To keep this change minimal, both TxIn/TxOut still use the parameter
object for initialization.  TxOut accepts only the types it uses
internally, and not hex or byte arrays for scripts.

It also no longer clones the input scripts inherently in the default
case, as this is unnecessary and is not coherent with the rest of
the project.

This resulted in TransactionOut.scriptPubKey no longer being needed,
and was removed.  To access the scriptPubKey as a byte buffer, a user
can simply use:

	TransactionOut.script.toBuffer()

Unfortunately, this leaves TransactionOut in a sorry state of test.
Something that needs to be fixed.
Script/Transaction: Removes untested functions

These functions are not under test, and are unnecessary bloat due to a
confusing API.

Script.from*(asmStr) were two functions that attempted to parse ASM
codes and produce a script from this.
While useful, an parser can be introduced later under a single function
and under test... removed.

Although Script.extractPublicKeys implementation is likely to be correct,
it is not absolute in that what it returns is even strictly a set of
public keys.
It is a useful function, but can be done in a better way later,
probably checking against the Script templates instead.

Transaction.signWithKeys has some inherent undocumented behaviour, and it is not
clear when you would use it over just Transaction.addOutput and
Transaction.sign individually.  Nor does it mimic anything in the
bitcoind API... removed.
Script: Fix assertion message grammar
Script: More consistent input handling

The template following throughout the project is usually to check/set
the defaults at the top of the function, and then (in the case of a
constructor) set them after.
Having default arguments/blank scripts is a bit of a smell anyway, will
see what I can do to remove this later...
Network: Rename Network to Networks

Network, network, net, networkString.  Was becoming a bit painful.
Often we are selecting a network from the known network constants
(plural).  Therefore, I have changed the module to be a plural.

Seems to remove the most common ambiguities.
As Network is not a class abstraction, the lower case has also been
used.
Script: Add to/fromHex

Script.fromHex already existed, but was not under any kind of test.
This commit adds tests (despite being a little circular in nature) to
check that the output is as expected.

It also adds Script.toBuffer/toHex.
It should be noted that throughout the project, toHex is consistently a
wrapper around *.toBuffer, this means we can test both at the same time
using only the wrapper (*Hex).
It is probably up for discussion whether this is good practice or not.
Script: Add standard Script.create*ScriptPubKey

Extracts the two Script types out of Script.createOutputScript, and puts
them both under test.
This means for stricter more testable code.

Also renames Script.createMultiSigOutputScript to adhere to the same
convention.
Address: Add Address.*ScriptPubKey and tests

The introduction of these two functions allow for the all the network
related code to be hopefully removed from Transaction and Script.
Both abstractions have no business caring about which network they are being
used for; and this change (and future changes) will hopefully reflect
that.

The search of the network constants is a bit ugly, admittedly, but this
can be refined later.
Previously the result was undefined behaviour for non-standard
transactions; by using these functions, this is no longer the case and
instead an exception will be thrown.
Address: Use Address.Error instead

It is very difficult to selectively rethrow an Error when all standard
Errors derive from it.
Perhaps a better error handling mechanism should be used in place of
this, because frankly, its not the nicest solution... callbacks?
Transaction: Network should not be implied in Tx.deserialize

In most cases, a Transaction has no idea, nor is it capable of,
presenting the Base58 of a PubKeyHash or ScriptHash.
This is because both of these Address types use network specific
constants.

To make Transaction uncoupled from the network, the removal of
TransactionOut.address will be necessary.  Unfortunately, this is
heavily used around the project (exhibiting one of the main reasons why
this library is not yet compatible with alternative networks).
In making a step towards this goal, Transaction.deserialize will now
never attempt at making a guess towards the Network (previously only
giving correct Addresses for the Bitcoin network), and instead leave
TransactionOut.address as undefined.

TransactionOut.address will only be defined in the case of
Transaction.addOutput, which is naturally most often used in form:
Transaction.addOutput(address, value).
Transaction/Script: Remove network coupling

This removes the coupling of Transaction/Script and network through the
use and resolution of Address type in Address.toScriptPubKey instead of
Script.createOutputScript.

This allows the removal of several functions in Script, all of which
attempted to guess at the type and network for an Address.

Unfortunately Transaction.sign still assumes that the signed scriptSig is a pubKeyHash
output however... this will be fixed soon enough.