Open files in binary mode, where appropriate.

Should have been doing this all along, as Python's default I/O mode is
text mode.  It won't make any difference in most cases, perhaps all,
but binary mode is certainly correct if we're being careful.

* onetime
  (Pad.__init__): Read the pad in binary mode.
  (Configuration.save): Add comment explaining why not binary mode.
  (main): Open input and output in binary mode.
* onetime
  (Pad._make_fuzz): Explain why we read 4 bytes.
  (PadEncoder.encode): Remove old comment.
Update pad consumption when doing the new fuzz skipping.

This fixes a bug introduced in commit 52e24e550 that would result in
re-use of pad data.  This also makes some regression tests start
failing, because the used lengths they're expecting are now different;
I will fix the tests in a subsequent commit.

* onetime (Pad._make_fuzz): Adjust pad used length.  I mean, duh.
Update regression tests, as promised in commit e3a8e7168.

Along the way, fix some conditionals that would behave correctly when
succeeding but report a syntax error when unexpectedly failing.  What
happened was that 'grep -n' would produce no output in the failure
case, and that absence of output in the left half of a shell test
would cause the '-ne' operator to be a syntax error when reached.
* onetime (__version__): Increment to 2.0-beta2.
Start on issue #5: document the inner headers plan.

* onetime (Pad._make_fuzz): Describe a plan for inner headers in a
    comment here, explaining how it will support both sender-chosen
    noise length and future extensibility while revealing nothing
    about the version of OneTime used other than that it's >= 2.0.
Recommend smaller block size for 'dd' to generate pads.

* onetime
  (pad_generation_help): Adjust documentation accordingly.
Emphasize how long pad generation can take.

* onetime (pad_generation_help): Add parenthetical aside.
Fix a mistake in a rarely-issued error message.

* onetime
  (Configuration.register): Pass correct format version to pad.id().
Make the "Format:" plaintext header represent only format level.

This is part of the shift to using so-called "inner headers" to
specify detailed format information, as revived in commit 04974c7fe.
That shift is not complete yet, but the changes below take care of the
user-visible part of it.

* onetime
  (Format_Level): Replaces Format; redocument.
  (FormatLevel): Replaces FormatVersion exception.
  (Pad.convert): Take format_level as a string instead of
    format_version as a number.
  (PadDecoder.decode): Check format_level now, as a string.
  (PadDecoder.__init__): Take format_level instead as a string instead
    of input_format as a number.  Also, get rid of an error check that
    will no longer happen here, because it will happen where the real
    format version, the one embedded in the ciphertext, is obtained.
  (Pad._make_fuzz): Update comments accordingly.
  (Configuration._get_next_offset): Update doc string.
  (Pad._get_original_format_level_id): Replaces Pad._get_v1_id.
  (Pad.__init__, Pad.id, Configuration.register, main): Adjust for above.
Consistify some terminology, following up to commit 0d6934110.

* onetime
  (PadDecoder.__init__): Doc fix and error message fix.
  (PadDecoder.decode): Comment fix.
Publish 1.x line releases while 2.0 is in development.

* index.html-top, get.html-tmpl: Adjust accordingly.
* Makefile: Adjust the substitutions.
* make-dist.sh, find-ver.sh: New helper scripts.
Remove an unnecessary helper method to avoid confusion.

Internally, the word "encode" is a bit overloaded: we use it to mean
plaintext data that has been compressed and then encrypted against the
pad, but we're also doing Base64 encoding.  Having the Base64 encoding
happen in a separate function just increased the chance of confusion.
After this change, "encode" really means all the steps, including the
Base64 encoding, and is once again symmetrical with the decoder.

* onetime
  (PadEncoder._output): Remove this method.
  (PadEncoder.encode, PadEncoder.finish): Adjust accordingly.
* onetime (main): Fix typo and phrasing in a comment.
* onetime (main): Bring an old comment up to date.
Start reshaping the code for modern format with inner headers.

This does not change the output yet, but it prepares the way for the
full implementation of the modern format, in which format and other
details are encrypted with pad and are part of the encoded output.

* onetime
  (Pad.OverPrepared): New exception class.
  (Pad._make_inner_headers): Renamed from Pad._make_fuzz.
  (Pad.__init__): Add new instance booleans _encoding and _decoding.
  (Pad.prepare_for_encoding, Pad.prepare_for_decoding): New methods.
  (Pad.convert): Revamp initialization logic as per above.
  (PadEncoder.__init__): Prepare pad for encoding.
  (PadDecoder.__init__): Prepare pad for decoding.
* images/logo/: Add logos from Felicia Doolin (fdooli.info).

* .gitignore: Tweak to not match the logo file names.
Get inner headers working.

Test suite adjustment remains, but this passes basic tests.

* onetime
  (Pad.__init__): Set default fuzz source length and modulo here.
  (Pad.InnerFormat): New exception class.
  (Pad._make_fuzz_length_from_pad, Pad._skip_bytes): New helper methods.
  (Pad._make_inner_headers): Renamed to...
  (Pad._make_inner_header): ...this; all callers changed.  Rewrite to
    calculate the inner header in the new way and return it.
  (Pad._handle_inner_header): New method.
  (Pad.convert): Handle generating and reading inner headers.
  (main): Say more possibilities in the decoding error message.

* check.sh: Adjust expected outputs.
Make test suite pass with new inner headers.

* onetime
  (PadDecoder.decode): Wrap certain exceptions in DecodingError.
  (main): Catch PadDecoder.DecodingError to remove output file.

* check.sh: Adjust expected outputs.
Call internal format "internal", not "modern".  Enforce it more.

* onetime:
  (Format_Level): Change to "internal".  Replace "modern" with
    "internal" wherever appropriate in code and comments.
  (PadDecoder.decode): Undo exception-wrapping of commit e62d3104ec5.
    Instead we will catch all expected exception types in the caller,
    because Python 2.x doesn't have true exception wrapping.
  (Pad._handle_inner_header): Enforce values in first flag byte.
  (main): Adjust for exception changes in PadDecoder.decode.

* check.sh: Adjust for above exception change.