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: remove 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 toHex, 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/Script: Bitcoin network no longer implied

A Transaction has no idea, nor is it capable of: retrieving the
Base58 of a PubKeyHash or ScriptHash.
This is because both of these Address types use network specific
constants for the generation of their Base58 representation.

To make Transaction uncoupled from the network, the removal of
TransactionOut.address will be necessary.  Unfortunately, this is
a heavily used field around the project (exhibiting one of the main
reasons why this library is not fully compatible with testnet).

For now, 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 is only defined in the case of Tx.addOutput:

      Transaction.addOutput(address, value).

Finally, and unfortunately, Transaction.sign still assumes that the
signed scriptSig is a pubKeyHash output... this will be fixed soon enough.