Using repository on top of Entity Framework is always a bad practice . In this answer, I only solve the generic code problem that the questioner is having, but that does not validate the use of the practice in any application whatsoever.

  

Am I shaping the pattern wrong?

No, it's correct. There are only a few adjustments left.

  

How can I solve the first error without the need for gambiarra and without having to make my domain classes inherit from IDisposable?

Yes, see below.

  

How to resolve the second error?

Switch:

public abstract class CustomRepository<T> where T : class, IRepository<T> , IDisposable
{ ... }

To:

public abstract class CustomRepository<T>: IRepository<T>, IDisposable
    where T : class
{ ... }

Repository Layer

The class Abstract Respository is the place where the default encoding is done, having implemented the IRepository Interface.

Interface

public interface IRepository<T> : IDisposable where T : class, new()
{
    T Create();
    DbSet<E> Create<E>() where E : class, new();        
    T Insert(T model);
    bool Edit(T model);
    bool Delete(T model);
    bool Delete(Expression<Func<T, bool>> where);
    bool Delete(params object[] Keys);
    T Find(params object[] Keys);
    T Find(Expression<Func<T, bool>> where);
    IQueryable<T> Query();
    IQueryable<T> Query(params Expression<Func<T, object>>[] includes);
    IQueryable<T> QueryFast();
    IQueryable<T> QueryFast(params Expression<Func<T, object>>[] includes);
    DbContext Context { get; }
    DbSet<T> Model { get; }
    Int32 Save();
    Task<Int32> SaveAsync();
}

Abstract

DbEntities would be your main context

public abstract class Repository<T> : IRepository<T> where T : class, new()
{   
    public Repository()
    {
        this.Context = Activator.CreateInstance<DbEntities>();
        this.Model = this.Context.Set<T>();
    }
    public Repository(DbContext Context)
    {
        this.Context = Context;
        this.Model = this.Context.Set<T>();
    }
    public T Insert(T model)
    {
        this.Model.Add(model);
        this.Save();
        return model;
    }
    public bool Edit(T model)
    {
        bool status = false;
        this.Context.Entry<T>(model).State = EntityState.Modified;
        if (this.Save() > 0)
        {
            status = true;
        }
        return status;
    }
    public bool Delete(T model)
    {
        bool status = false;
        this.Context.Entry<T>(model).State = EntityState.Deleted;
        if (this.Save() > 0)
        {
            status = true;
        }
        return status;
    }
    public bool Delete(System.Linq.Expressions.Expression<Func<T, bool>> where)
    {
        bool status = false;
        T model = this.Model.Where<T>(where).FirstOrDefault<T>();
        if (model != null)
        {
            status = Delete(model);
        }
        return status;
    }
    public bool Delete(params object[] Keys)
    {
        bool status = false;
        T model = this.Model.Find(Keys);
        if (model != null)
        {
            status = Delete(model);
        }
        return status;
    }
    public T Find(params object[] Keys)
    {
        return this.Model.Find(Keys);
    }
    public T Find(System.Linq.Expressions.Expression<Func<T, bool>> where)
    {
        return this.Model.Where<T>(where).FirstOrDefault<T>();
    }
    public IQueryable<T> Query()
    {
        return this.Model;
    }
    public IQueryable<T> Query(params Expression<Func<T, object>>[] includes)
    {
        IQueryable<T> Set = this.Query();
        foreach (var include in includes)
        {
            Set = Set.Include(include);
        }
        return Set;
    }
    public IQueryable<T> QueryFast()
    {
        return this.Model.AsNoTracking<T>();
    }
    public IQueryable<T> QueryFast(params Expression<Func<T, object>>[] includes)
    {       
        IQueryable<T> Set = this.QueryFast();
        foreach (var include in includes)
        {
            Set = Set.Include(include);
        }
        return Set.AsNoTracking();

    }
    public T Create()
    {
        return this.Model.Create();
    }
    public DbSet<E> Create<E>()
        where E: class, new()
    {            
        return this.Context.Set<E>();
    }
    public System.Data.Entity.DbContext Context
    {
        get;
        private set;
    }
    public System.Data.Entity.DbSet<T> Model
    {
        get;
        private set;
    }
    public void Dispose()
    {
        if (this.Context != null)
        {
            this.Context.Dispose();
        }
        GC.SuppressFinalize(this);
    }
    public int Save()
    {
        return this.Context.SaveChanges();
    }
    public async System.Threading.Tasks.Task<int> SaveAsync()
    {
        return await this.Context.SaveChangesAsync();
    }
}

Respository Album

Note that this is one of Repository , that is, if you have more you need to create classes in this way inheriting from Class Abstract Respository . Example RepositoryNoticia , RepositoryCliente , etc.

public class RepositoryAlbum : Repository<Album>
{
    public RepositoryAlbum() { }
    public RepositoryAlbum(DbContext Context) : base(Context) { }   
}

Instantiating layer

Repository<Album> RepAlbum = new RepositoryAlbum();