Fix Int64.toRadixStringUnsigned extra leading digits (#926)

Currently `Int64.toRadixStringUnsigned` adds an extra '0' when the result is
single digit, e.g. '02' instead of '2'.

To be able to use the standard library `toRadixString`, we split the number
into two halves, then calculate the lowest digit and the rest of the digits
separately. With the lowest digit removed, the rest of the digits can be passed
as a positive integer to `toRadixString`. The resulting strings are then
concatenated to get the final result.

The problem occurs when the number can be printed as a single digit. In this
case the rest of the number is printed as '0', giving us e.g. '02' instead of
'2'.

To fix, we return early by calling the standard library `toRadixString` when
the number is positive.

This works because

- The problem is only when printing single digits (as the lowest digit and the
  rest are printed separately, and the problem is when the "rest" part is 0)

- Single-digit numbers need to have high 32-bits as zero (otherwise they'll be
  negative and printed as many digits, or positive but larger than single
  digit).

- When the high 32-bits are all zero, the number is positive, and can be
  converted to string directly with the standard library signed
  `toRadixString`.

Author: osa1

pkgs/fixnum/lib/src/int64_native.dart

@@ -364,8 +364,8 @@ class Int64 implements IntX {
       throw ArgumentError('toStringRadixUnsigned radix must be >= 2 and <= 36'
           ' (found $radix)');
     }
-    if (value == 0) {
-      return '0';
+    if (value >= 0) {
+      return value.toRadixString(radix);
     }
     // Split value into two 32-bit unsigned digits (v1, v0).
     final v1 = value >>> 32;

pkgs/fixnum/test/int64_test.dart

@@ -1140,7 +1140,24 @@ void main() {
     });
 
     test('toStringUnsigned', () {
-      List<Int64> values = [];
+      expect(Int64.MAX_VALUE.toStringUnsigned(), '9223372036854775807');
+      expect(Int32.MAX_VALUE.toInt64().toStringUnsigned(), '2147483647');
+      expect(Int64(2).toStringUnsigned(), '2');
+      expect(Int64(1).toStringUnsigned(), '1');
+      expect(Int64(0).toStringUnsigned(), '0');
+      expect(Int64(-1).toStringUnsigned(), '18446744073709551615');
+      expect(Int64(-2).toStringUnsigned(), '18446744073709551614');
+      expect(
+          Int32.MIN_VALUE.toInt64().toStringUnsigned(), '18446744071562067968');
+      expect(Int64.MIN_VALUE.toStringUnsigned(), '9223372036854775808');
+
+      List<Int64> values = [
+        Int64.MAX_VALUE,
+        Int64(1),
+        Int64(0),
+        Int64(-1),
+        Int64.MIN_VALUE,
+      ];
       for (int high = 0; high < 16; high++) {
         for (int low = -2; low <= 2; low++) {
           values.add((Int64(high) << (64 - 4)) + Int64(low));