Take the errors in `main()` that check the response body contents for
known error strings and put them in their respective functions in
"timetask/http.go".

Didn't really make sense to me that these functions were returning HTTP
responses that we weren't really using in a meaningful way. Instead they
should just do their thing and let us know if there was a problem.

That includes checking to see if there were any non-standard errors,
like the ones we had custom-built. Now all that handling and
error-making is self-contained, which feels much nicer.

Parse the module XML with `ModuleParseXML()`. Take the resulting
`[]Module` slice and use it to generate a string of the following
format:

    ID	Module
    55555	R&D
    77777	Sprint 1
    222222 Sprint 2

This string is what gets printed to the console, which makes it rather
easy to read the modules that are available for the given project and
grab the appropriate ID to put into your config file.

Prefix the function name to make it more obvious what it relates to.
Since this function lives in the `timetask` module and will be used in
contexts that have nothing to do with Modules.

A new function that parses the XML returned by the `RequestModules()`
function.

It provides a `Module` type that allows us to interact with modules more
easily in code.

The `ParseXML()` function will take an XML string and return a slice of
`Module`s.

Added a test just to facilitate development. Wasn't able to find an easy
way to compare slices in Go, so just printed the values and checked the
result visually. Not a useful test for future use, but it served its
purpose. Eventually it would be nice to find a way to compare structs
and have a real pass/fail condition.

`Login()` now returns 3 values. Update the test.

Sprints will change with time while the other IDs of a project will stay
the same. Thus sprints, which live in the `Module` field, must be
updated regularly.

In order to facilitate that updating, instead of requiring users to get
those IDs directly from the TimeTask website every time, have them use
this command to get the names of sprints and their IDs. They can then
update the ID manually in their config file.

This code makes a request to the endpoint that returns module IDs for
the site (the site queries this via AJAX to update its interface).

The result of the request is some XML containing the modules and their
IDs. For now I'm just printing this out. We'll want to parse the XML and
display it in a nicer way.

We ran into a bug where submitting "7" as the time spent would become
"700" on the site.

This was because our `n` value of 0 wasn't replacing the "." in the
string. Thus "7.00" became "7.00" after the replacement. Not right. I
misunderstood what that argument was doing and what the word "empty" in
the documentation meant.

Change the `n` value to replace all "."s in the string.

I had forgotten that time spent can be a decimal. Make this field a
float and change related code accordingly:

* --time flag
* `NewTimeEntry()` `time` argument
* `buildSubmissionParams()` can't use `strconv.Itoa` as that's an
  integer function. Instead we use `FormatFloat`. Truncate time parsing
  to two decimal places because to me that seems like enough. Who's
  going to say they spent `0.324` hours on something? Also, in order to
  be able to properly submit values to TimeTask (at least on the edition
  I use), the times must be written in European/French format, with
  commas (`,`) as decimal separators. Do a string replace to get this,
  as the float formatter will give us a period (`.`) separator.