**Use case**
Very rare deadlock is possible.

**Describe the solution you'd like**
If MemoryTracker is called from operator new, don't:
- log anything (1);
- throw (2).

(1) is strictly necessarily to avoid deadlock;
(2) is almost necessarily to avoid tons of peculiarities in destructors.
{
    auto peak_old = peak.load(std::memory_order_relaxed);
    if (will_be > peak_old)        
    {
        peak.store(will_be, std::memory_order_relaxed);
        if ((level == VariableContext::Process || level == VariableContext::Global)
            && will_be / log_peak_memory_usage_every > peak_old / log_peak_memory_usage_every)
            logMemoryUsage(will_be);
    }
}
void MemoryTracker::free(Int64 size)
{
    if (BlockerInThread::isBlocked(level))
    {
        
        if (auto * loaded_next = parent.load(std::memory_order_relaxed))
            loaded_next->free(size);
        return;
    }
    std::bernoulli_distribution sample(sample_probability);
    if (unlikely(sample_probability && sample(thread_local_rng)))
    {
        BlockerInThread untrack_lock(VariableContext::Global);
        DB::TraceCollector::collect(DB::TraceType::MemorySample, StackTrace(), -size);
    }
    Int64 accounted_size = size;
    if (level == VariableContext::Thread)
    {
        
        amount.fetch_sub(accounted_size, std::memory_order_relaxed);