Allow a user to pass an IO object when adding a font

This PR lets 

```ruby
require 'bundler'
Bundler.setup
require 'prawn'
require 'open-uri'
pdf = Prawn::Document.new
pdf.font_families.update(
  "MyFont" => {
    format: 'ttf',
    bold: open("https://mybucket.s3.amazonaws.com/myfont.ttf")
  }
)
pdf.font("MyFont", :style => :bold)
pdf.text "Some bold text"
pdf.render_file 'output.pdf'
```

Work as expected. The big thing to notice is when passing in an IO object we need to also pass in a format: key so Prawn knows what kind of format the font is. Normally prawn uses the file extension at the end of a path to determine what format the file is in, TTF, DFONT or AFM. Really I don't think this is ideal either, where I would prefer to see the TTF class be able to tell you if a given binary stream is a TTF file or not (really asking the class if it can work with said binary stream). I glanced at the TTF spec and it didn't look incredibly easy (no simple magic number at the head of the file).

The other thing I notice is the `name` variable isn't really the font name so much as either the path the user supplied or the IO object for the font, I didn't refactor all the methods to use a more correct name but I did leave a comment in the method. If we think it's worth doing now I can try to make that update but I didn't want to risk mucking up the font code as this is the first time I have really gotten into it.

I also changed the gemfile to require a more recent commit of TTFunk as mentioned in [TTFunk Pull #17](https://github.com/prawnpdf/ttfunk/pull/17), once we are ready to merge the code we can remove that and instead cut a new release of TTFunk and make prawn require that release.

Any thoughts? It works, but it's not quite ideal.
I was thinking about having a real object for `FontFamily`, but I still don't know what I'd want the interface to look like for that and I'm hesitant to rush into defining it.

I like the idea of smart detection via some sort of FontHandler protocol, so that may be worth experimenting with.

But I'm also okay with the idea of just having the hash stay as it is. It isn't highly complex to say "either convert the string into a font object, or if you've already been provided a font object, use it directly without attempting any processing".

Even if we make `Font.load()` smart so it can return the right font object based on the binary stream, we're still going to need to make those fonts usable by families. So let's start w. making this tiny change to families (values can be strings or pre-loaded Font objects), and a small change to `Font.load` (either intelligently detect format or let it be explicitly specified, i.e. `Font.load(src, :format => :ttf)`, with `:ttf` being default).

From there, we can evaluate how well used the feature is and what might be a way to formalize the APIs further.