wordy: Rework API so errors fail faster

[petertseng]

https://github.com/exercism/rust/blob/master/exercises/wordy/tests/wordy.rs#L106 I will reproduce here for convenience:

    assert!(WordProblem::new(command).answer().is_none());

However, at the time of parsing command, we can know whether the command is valid. We don't need to wait until calling answer().

The reasons for solving this problem, regardless of what way is used to solve it, are that it's a better interface to fail as soon as possible when you know you will fail. It's harder on consumers of an interface if they have to trace back their own actions to figure out exactly where in the past they went wrong.

A possible solution would be to simplify the interface to:

answer_word_problem(command: &str) -> Option<i32>

I suggest such a simplification, similar to same simplification done for brackets in #620

The additional reason for the simplification as the particular way to solve this problem would be to not force the creation of a struct where it is not necessary.

[coriolinus]

I agree that an API which fails fast is better than one which fails slow. I agree that simplifying the interface as suggested would improve the exercise.

[coriolinus]

Looks like I felt the same way when I implemented this exercise a year ago:

    // Not a fan of this style; I'd greatly prefer the constructor
    // pub fn new(command: &str) -> Option<WordProblem>
    //
    // I get that it makes testing a little simpler to do it like this,
    // but in real life, I want errors to show up as soon as possible,
    // so that you can fix them immediately. This implies parsing
    // problems like this in the constructor, so that the errors at least
    // stay local. Otherwise, you have invalid WordProblems floating around
    // within your code, just waiting for someone to call `.answer()`
    // somewhere entirely nonlocal, before they strike.