Каков эффективный способ удаления данных из потока (или TextWriter)?

Вы можете реализовать Stream, который оборачивает входной поток. Он не оптимизирован, как Sep, но его также легко сравнивать с чем-то более оптимизированным, но при этом он не особенно неэффективен (не буферизует весь ввод в память, не добавляет копирования или декодирования).

using System;
using System.Diagnostics;
using static System.IO.Stream;

/// <summary>
/// Replaces all instances of <c>\"</c> with <c>""</c> in an ASCII-compatible stream.
/// </summary>
class ReplacementHack : Stream {
    private Stream Wrapped;

    /// <summary>
    /// Up to one byte of buffered data that's been read from the underlying stream but not read from this stream.
    /// </summary>
    private byte? Buffered = null;

    public override bool CanRead => true;
    public override bool CanWrite => false;
    public override bool CanSeek => false;

    public ReplacementHack(Stream wrapped) {
        this.Wrapped = wrapped;
    }

    public override int Read(byte[] buffer, int offset, int count) =>
        this.Read(new Span<byte>(buffer, offset, count));

    public override int Read(Span<byte> buffer) {
        if (buffer.IsEmpty) {
            return 0;
        }

        int r;
        if (this.Buffered is byte b) {
            this.Buffered = null;
            buffer[0] = b;
            r = checked(1 + this.Wrapped.Read(buffer.Slice(1)));
        } else {
            r = this.Wrapped.Read(buffer);
        }

        this.Transform(buffer.Slice(0, r));

        return r;
    }

    private void Transform(Span<byte> buffer) {
        if (buffer.IsEmpty) {
            return;
        }

        const byte ASCII_BACKSLASH = 0x5c;
        const byte ASCII_DQUOTE = 0x22;

        // Replace all complete instances of \" in the buffer.
        for (int i = 0; i < buffer.Length - 1; i++) {
            if (buffer[i] == ASCII_BACKSLASH && buffer[i + 1] == ASCII_DQUOTE) {
                buffer[i] = ASCII_DQUOTE;
                i++;
            }
        }

        // If the last byte of the buffer could be the start of \", peek one character ahead to resolve it.
        if (buffer[buffer.Length - 1] == ASCII_BACKSLASH) {
            var peek = this.Wrapped.ReadByte();

            if (peek == -1) {
                Debug.Assert(this.Buffered is null);
            } else {
                this.Buffered = (byte)peek;

                if (peek == ASCII_DQUOTE) {
                    buffer[buffer.Length - 1] = ASCII_DQUOTE;
                }
            }
        }
    }

#region Non-seekable stream
    public override long Length => throw new NotSupportedException();
    public override long Position {
        get { throw new NotSupportedException(); }
        set { throw new NotSupportedException(); }
    }
#endregion

#region Read-only stream
    public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
    public override void Flush() {}
    public override long Seek(long offset, System.IO.SeekOrigin origin) => throw new NotSupportedException();
    public override void SetLength(long length) => throw new NotSupportedException();
#endregion
}

(Если вы обнаружите, что это недостаточно быстро, как я уже упоминал в комментарии, рассмотрите возможность размещения его между сетью и диском, а не между диском и сентябрем.)

Дополнение ОП с результатами испытаний:

valid: Unfiltered: 396ms  (raw Sep speed)
valid: Filtered: 490ms
broken: Unfiltered: Exception was thrown
broken: Filtered: 478ms

Отфильтрованные и нефильтрованные результаты в действительном файле также хэшируются с одним и тем же значением, показывая, что, если недопустимая последовательность символов не обнаружена, поток полностью не изменяется. Файлы считывались один раз до каких-либо результатов синхронизации, поэтому при всех запусках использовались файлы, кэшированные в оперативной памяти.