Q:

Why is a const variable declared as a class member still modifiable?

If a const variable which has been assigned can still be reassigned, then it's not a const? Take for instance:
 struct ss
 {
     const int m = 1024;

     ss()
     {
     }

     ss(int m) : m(m)
     {
     }
 };

ss sa;
ss sb(-1);

cout << sa.m << endl;
cout << sb.m << endl; 

Wow m is not constant after all!

> /* Ouput:
> 
> 1024
> -1
> 
> */

A:

 ss(int m) : m(m)
 {
 }

This says that when the class ss is initialized, its member m is initialized using the parameter m. The member m indeed cannot be modified, but it can be initialized, just like any other const object. Note that if we did instead
 ss(int m)
 {
     this->m = m;
 }

then we would have a problem, as ss::m needs to be initialized. And if ss::m were a class with a default constructor, then in
 ss(FooClass m)
 {
     this->m = m;
 }

it's OK to not initialize ss::m explicitly (as it will just be default-constructed), but the line in the body of the constructor would be rejected as it would modify ss::m after it has already been initialized.
Edit: Whoops, I didn't understand your original question.
A brace-or-equal-initializer such as 
const int m = 1024;

is only used if the member is not mentioned in the ctor-initializer. In other words, since the default constructor doesn't explicitly initialize m, the value 1024 is used. But ss::ss(int) does explicitly initialize m, so the brace-or-equal-initializer is ignored.

A:

Your example just deals with different modes of initialization, no reassignment is happening here. What you are seeing is the effect of the constructors initializer list being preferred over the in class member initializer, we can see from the draft C++ standard section 12.6.2 Initializing bases and members paragraph 9 which says:

If a given non-static data member has both a
  brace-or-equal-initializer and a mem-initializer, the initialization
  specified by the mem-initializer is performed, and the non-static data
  member’s brace-or-equal-initializer is ignored. [ Example: Given
struct A {
int i = / some integer expression with side effects / ;
A(int arg) : i(arg) { }
// ...
};

the A(int) constructor will simply initialize i to the value of arg,
  and the side effects in i’s brace-orequal- initializer will not take
  place. —end example ]

As discussed in Has the new C++11 member initialization feature at declaration made initialization lists obsolete? this is a useful features since it allows you to default member variables and then override those defaults based on the constructor that is called.

