Provide faster implementation for whereNotNull

[mraleph]

Replace sync* with handwritten implementation for now. We can undo the change if sync* becomes as fast as handwritten code.

Closes #273

[devoncarew]

Ping @lrhn for a review.

@mraleph - can you add a changelog entry for this change (and rev the pubspec version if necessary)?

[lrhn]

Use var, not final.

We don't generally use final for locals.

[natebosch]

final locals is getting enforcement internally and is very likely the direction we'll go with Dash team packages as well.

[lrhn]

Still, keep the style here consistent until we do make a change. Don't mix styles.

[lrhn]

Use => _current ?? (throw StateError("no element")).

[lrhn]

extends Iterable<T>.

[lrhn]

Should we do

  var self = this;
  if (self is Iterable<T>) return self;
  return _NotNullIterable<T>(this);
}

Probably not worth it, but we don't have a good way to prevent you from using the method on Iterable<int>.
(We could put a Never whereNotNull() => throw "Not needed!"; as extension <T extends Object> on Iterable<T>, then you'd see if you get that instead.)

[gmpassos]

This is a very important check, since it transform a new Iterable instance (_NotNullIterable) to just a casting.

Since the extension is resolved in the variable level, not in the instance:

void main() {
  
  List<int?> l1 = <int>[1,2];
  List<int> l2 = <int>[3,4];
  List<int?> l3 = <int?>[1,2];
  
  print(l1.isNullable);
  print(l2.isNullable);
  print(l3.isNullable);
  
}

extension _ItrExt<T extends Object> on Iterable<T> {
  String get isNullable => "NO<T>";
}

extension _ItrNullableExt<T extends Object> on Iterable<T?> {
  String get isNullable => this is Iterable<T> ? "NO<T?>" : "YES<T?>";
}

/////////////////
// OUTPUT:
/////////////////
// NO<T?>
// NO<T>
// YES<T?>

[lrhn]

We now have .nonNulls getter in the platform libraries which does the same thing.

We should optimize that if necessary, and make collection just forward to the platform library version when we upgrade to requiring SDK 3.0.