A profile shows indeed that it uses Contains. The reason the flag is set is that because the entities in the collection are unique, adding a duplicate one isn't what you want. It currently relies on a simple seek using Contains() which is OK for general use. There's really not much else there's to do without introducing a memory hungry index, as the context can't be used to determine whether the entity to add is present in the collection (see below)
The problem occurs during merge of the fetched prefetch path, which uses Add().
I have to ask... why fetch 250,000 entities at all? A m:n relationship might contain many more entities over time (e.g. millions), which your code will fetch all then too. This isn't sustainable, you should work with smaller sets in memory.
In any case, the flag can't be switched off by default, that's a breaking change which we won't make in a fix as some code might rely on that. It's a problematic situation, as there's no fix which doesn't break anything or changes the templates (which we don't want to do either as many people have made subtle changes to the entity templates and we like to keep them as-is for now and won't change them mid-release in a fix).
The main thing is that what's in the collection is in the context, but what's in the context isn't necessarily in the collection (your root entity is in the context, not in the m:n collection for example). So although the context contains a set of pk hashes for fast checking whether an entity is present in it, it can't be used to test whether an entity is present in the collection. As this is a merge resulting from a fetch, it is highly likely the entity added to the collection isn't present, but the code used for that doesn't know (it uses the regular 'Add()' method, not a shortcut).
Though there's a workaround. Change your code to:
using (var adapter = new DataAccessAdapter(@"..."))
{
var group = new SysGroupEntity(groupId);
group.ActiveContext = new Context();
group.Members.DoNotPerformAddIfPresent = false;
adapter.FetchEntity(group, new PrefetchPath2(EntityType.SysGroupEntity) { SysGroupEntity.PrefetchPathMembers });
group.Members.DoNotPerformAddIfPresent = true; // or not, if you don't need this functionality.
Here you assign the context to the entity before the fetch. It's the same as passing it to the method, as it gets assigned to the entity in the method you called. Assigning it before the fetch and then accessing the collection will create the collection and add the context to it, setting the flag. You can then reset it as you don't want it to be set. Your fetch then doesn't need to receive the context (as the entity fetched already contains the context so it's used) and as the flag isn't set, Members.Add() should be fast.
We'll look into solving this problem in the next release, as that's a way to introduce some changes needed for this which we can't do mid-release in a patch.
In any case, even though the workaround will make your fetch faster, you really shouldn't fetch that many entities in a normal query, unless you are processing them for something but even then it often is much faster do bring the processing to the data than vice versa
Hope this helps.