skip unnecessary check during double-check SizeClass intergrity

On initialization step, tcmalloc double-checks SizeClass integrity with
all possible size values, 0 to kMaxSize. This causes tremendous overhead
for short-lived applications.

For example, consider following command.
'find -exec grep something {} \;'

Actual work of each grep is really small, but double-check requires
more work. To reduce this overhead, it is best to remove double-check
entirely. But we cannot be sure the integrity without double-checking,
so alternative is needed.

This patch doesn't remove double-check, instead, try to skip unnecessary
check based on ClassIndex() implementation. This reduce much overhead and
the code has same coverage as previous double-check. Following is
the result of this patch.

time LD_PRELOAD=libtcmalloc_minimal.so find ./ -exec grep "SOMETHING" {} \;

* Before
real	0m3.675s
user	0m1.000s
sys	0m0.640s

* This patch
real	0m2.833s
user	0m0.056s
sys	0m0.220s

* Remove double-check entirely
real	0m2.675s
user	0m0.072s
sys	0m0.184s
central_freelist: fetch objects as much as possible during each trial

It is better to reduce function call if possible. If we try to fetch
objects from one span as much as possible during each function call,
number of function call would be reduced and this would help performance.
central_freelist: change fetch ordering

When we fetch objects from the span for thread cache, we make
reverse-ordered list against original list on the span and suppy this list
to thread cache. This algorithm has trouble with newly created span.
Newly created span has ascending ordered objects list. Since thread cache
will get reverse-ordered list against it, user gets objects as descending order.

Following example shows what occurs in this algorithm.

new span: object list: 1 -> 2 -> 3 -> 4 -> 5 -> ...
fetch N items: N -> N-1 -> N-2 -> ... -> 2 -> 1 -> NULL
thread cache: N -> N-1 -> N-2 -> ... -> 2 -> 1 -> NULL

user's 1st malloc: N
user's 2nd malloc: N-1
...
user's Nth malloc: 1

In general, access memory with ascending order is better than descending
order in terms of the performance. So this patch fix this situation.

I run below program to measure performance effect.

	#define MALLOC_SIZE (512)
	#define CACHE_SIZE (64)
	#define TOUCH_SIZE (512 / CACHE_SIZE)

	array = malloc(sizeof(void *) * count);

	for (i = 0; i < 1; i++) {
		for (j = 0; j < count; j++) {
			x = malloc(MALLOC_SIZE);
			array[j] = x;
		}
	}

	repeat = 10;
	for (i = 0; i < repeat; i++) {
		for (j = 0; j < count; j++) {
			x = array[j];
			for (k = 0; k < TOUCH_SIZE; k++) {
				*(x + (k * CACHE_SIZE)) = '1';
			}
		}
	}

LD_PRELOAD=libtcmalloc_minimal.so perf stat -r 10 ./a.out 1000000

**** Before ****
 Performance counter stats for './a.out 1000000' (10 runs):

       2.715161299 seconds time elapsed                                          ( +-  0.07% )

**** After ****
 Performance counter stats for './a.out 1000000' (10 runs):

       2.259366428 seconds time elapsed                                          ( +-  0.08% )