Lambda the Ultimate

What would be a contrasting problem?
A problem that would be awkward if the language is dynamically typed. Presumably straight-forward solutions would exploit the presence of static typing in the same way that Accumulator Generator exploits it's absence.

As for your contrasting problem, in static languages (that support generics) it is very is to define a general container that can hold only a specific type of object. If you use a dynamically typed language you have to resort to a container that can hold any type of object and must perform a test at runtime. This testing code, as well as the considerations of what to do if the test fails, add a layer of complexity.

Actually, I think overloading is the key here, since the problem requires that a single addition operator be used for any type of number. In fact, as another post observed, the problem is poorly specified, since few languages allow arbitrary mixing of numeric types (nor should they, necessarily). For example, suppose I do something like (pseudocode):

  f = foo 3
  f 5.3
  f Complex (3, 2i)
  f Rational (45, 123)

Should this really work?

If I were to specify the problem, I'd say foo takes two arguments: an initial value, and an incrementor function. Then foo is fully specified and can be easily implemented in a language with Hindley-Milner types:

fun foo initial add =
   let val store = ref initial
   in fn n => (store := add (!store, n); !store) end;

Then foo has type 'a -> ('a * 'b -> 'a) -> 'b -> 'a and we can use it however we like.

contrasting problem
You've both helped to change my mind ;-)
Thinking about a contrasting problem was wrongheaded.

Much more interesting would be a language that allowed a straightforward implemention of Accumulator Generator, and provided compile-time guarantees (so we can check that the function parameters are only ever numbers for which + is reasonable).

so we can check that the function parameters are only ever numbers for which + is reasonable

I'm not sure what you mean by reasonable in this context. Would an accumulator for strings (via concatenation) be reasonable in this context? For matrices?

Any statically typed language could provide such compile-time guarantee (provided that it does support the + operator for the types you want (and even more so if it allows overloading of this operator for user defined types).

If C++ was extended to provide proper scopes (along with function nesting and anonymous functions), a safe implementation in that language would have been short and trivial (IMO there is nothing in the C++ language that inherently precludes such an extension, aside from performance considerations).

"Works for any numeric type-- i.e. can take both ints and floats and returns functions that can take both ints and floats."
Let's stop there - ints and floats - and see what the solutions would be like.

Any statically typed language could...
and allow a straightforward implemention?
We could imagine that this exercise was tailor-made to point out that some languages, sometimes force programmers to jump through hoops ;-)
Let's be charitable and regard this as an exercise in Comparative Programming Languages, rather than language advocacy.

if X was extended...
Interesting as step 2 (what do we need to change/add so that we can have a straightforward solution using language X). Step 2 for OCaml.
And also an admission that, at present, we don't have that straightforward solution.